# Generated from \SQLite.g4 by ANTLR 4.8
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u009f")
        buf.write("\u06c6\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\3\2\3\2\7\2\u00a9")
        buf.write("\n\2\f\2\16\2\u00ac\13\2\3\2\3\2\3\3\3\3\3\3\3\4\7\4\u00b4")
        buf.write("\n\4\f\4\16\4\u00b7\13\4\3\4\3\4\6\4\u00bb\n\4\r\4\16")
        buf.write("\4\u00bc\3\4\7\4\u00c0\n\4\f\4\16\4\u00c3\13\4\3\4\7\4")
        buf.write("\u00c6\n\4\f\4\16\4\u00c9\13\4\3\5\3\5\3\5\5\5\u00ce\n")
        buf.write("\5\5\5\u00d0\n\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3")
        buf.write("\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5")
        buf.write("\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u00f0\n\5\3\6\3\6\3\6")
        buf.write("\3\6\3\6\5\6\u00f7\n\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00ff")
        buf.write("\n\6\3\6\5\6\u0102\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7")
        buf.write("\u010b\n\7\3\b\3\b\5\b\u010f\n\b\3\b\3\b\3\b\3\b\3\t\3")
        buf.write("\t\5\t\u0117\n\t\3\t\3\t\5\t\u011b\n\t\5\t\u011d\n\t\3")
        buf.write("\n\3\n\3\n\5\n\u0122\n\n\5\n\u0124\n\n\3\13\3\13\5\13")
        buf.write("\u0128\n\13\3\13\3\13\3\13\7\13\u012d\n\13\f\13\16\13")
        buf.write("\u0130\13\13\5\13\u0132\n\13\3\13\3\13\3\13\5\13\u0137")
        buf.write("\n\13\3\13\3\13\5\13\u013b\n\13\3\13\6\13\u013e\n\13\r")
        buf.write("\13\16\13\u013f\3\13\3\13\3\13\3\13\3\13\7\13\u0147\n")
        buf.write("\13\f\13\16\13\u014a\13\13\5\13\u014c\n\13\3\13\3\13\3")
        buf.write("\13\3\13\5\13\u0152\n\13\5\13\u0154\n\13\3\f\3\f\5\f\u0158")
        buf.write("\n\f\3\f\3\f\3\f\3\f\5\f\u015e\n\f\3\f\3\f\3\f\5\f\u0163")
        buf.write("\n\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\7\f\u016c\n\f\f\f\16")
        buf.write("\f\u016f\13\f\3\f\3\f\3\f\5\f\u0174\n\f\3\r\3\r\5\r\u0178")
        buf.write("\n\r\3\r\3\r\3\r\3\r\5\r\u017e\n\r\3\r\3\r\3\r\5\r\u0183")
        buf.write("\n\r\3\r\3\r\3\r\3\r\3\r\7\r\u018a\n\r\f\r\16\r\u018d")
        buf.write("\13\r\3\r\3\r\7\r\u0191\n\r\f\r\16\r\u0194\13\r\3\r\3")
        buf.write("\r\3\r\5\r\u0199\n\r\3\r\3\r\5\r\u019d\n\r\3\16\3\16\5")
        buf.write("\16\u01a1\n\16\3\16\3\16\3\16\3\16\5\16\u01a7\n\16\3\16")
        buf.write("\3\16\3\16\5\16\u01ac\n\16\3\16\3\16\3\16\3\16\3\16\5")
        buf.write("\16\u01b3\n\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\7\16")
        buf.write("\u01bc\n\16\f\16\16\16\u01bf\13\16\5\16\u01c1\n\16\5\16")
        buf.write("\u01c3\n\16\3\16\3\16\3\16\3\16\5\16\u01c9\n\16\3\16\3")
        buf.write("\16\3\16\3\16\5\16\u01cf\n\16\3\16\3\16\5\16\u01d3\n\16")
        buf.write("\3\16\3\16\3\16\3\16\3\16\5\16\u01da\n\16\3\16\3\16\6")
        buf.write("\16\u01de\n\16\r\16\16\16\u01df\3\16\3\16\3\17\3\17\5")
        buf.write("\17\u01e6\n\17\3\17\3\17\3\17\3\17\5\17\u01ec\n\17\3\17")
        buf.write("\3\17\3\17\5\17\u01f1\n\17\3\17\3\17\3\17\3\17\3\20\3")
        buf.write("\20\3\20\3\20\3\20\3\20\5\20\u01fd\n\20\3\20\3\20\3\20")
        buf.write("\5\20\u0202\n\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7")
        buf.write("\20\u020b\n\20\f\20\16\20\u020e\13\20\3\20\3\20\5\20\u0212")
        buf.write("\n\20\3\21\5\21\u0215\n\21\3\21\3\21\3\21\3\21\3\21\5")
        buf.write("\21\u021c\n\21\3\22\5\22\u021f\n\22\3\22\3\22\3\22\3\22")
        buf.write("\3\22\5\22\u0226\n\22\3\22\3\22\3\22\3\22\3\22\7\22\u022d")
        buf.write("\n\22\f\22\16\22\u0230\13\22\5\22\u0232\n\22\3\22\3\22")
        buf.write("\3\22\3\22\5\22\u0238\n\22\5\22\u023a\n\22\3\23\3\23\5")
        buf.write("\23\u023e\n\23\3\23\3\23\3\24\3\24\3\24\3\24\5\24\u0246")
        buf.write("\n\24\3\24\3\24\3\24\5\24\u024b\n\24\3\24\3\24\3\25\3")
        buf.write("\25\3\25\3\25\5\25\u0253\n\25\3\25\3\25\3\25\5\25\u0258")
        buf.write("\n\25\3\25\3\25\3\26\3\26\3\26\3\26\5\26\u0260\n\26\3")
        buf.write("\26\3\26\3\26\5\26\u0265\n\26\3\26\3\26\3\27\3\27\3\27")
        buf.write("\3\27\5\27\u026d\n\27\3\27\3\27\3\27\5\27\u0272\n\27\3")
        buf.write("\27\3\27\3\30\3\30\5\30\u0278\n\30\3\30\3\30\3\30\7\30")
        buf.write("\u027d\n\30\f\30\16\30\u0280\13\30\5\30\u0282\n\30\3\30")
        buf.write("\3\30\3\30\3\30\7\30\u0288\n\30\f\30\16\30\u028b\13\30")
        buf.write("\3\30\3\30\3\30\3\30\3\30\7\30\u0292\n\30\f\30\16\30\u0295")
        buf.write("\13\30\5\30\u0297\n\30\3\30\3\30\3\30\3\30\5\30\u029d")
        buf.write("\n\30\5\30\u029f\n\30\3\31\5\31\u02a2\n\31\3\31\3\31\3")
        buf.write("\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
        buf.write("\3\31\3\31\3\31\3\31\5\31\u02b5\n\31\3\31\3\31\3\31\3")
        buf.write("\31\5\31\u02bb\n\31\3\31\3\31\3\31\3\31\3\31\7\31\u02c2")
        buf.write("\n\31\f\31\16\31\u02c5\13\31\3\31\3\31\5\31\u02c9\n\31")
        buf.write("\3\31\3\31\3\31\3\31\3\31\7\31\u02d0\n\31\f\31\16\31\u02d3")
        buf.write("\13\31\3\31\3\31\3\31\3\31\3\31\3\31\7\31\u02db\n\31\f")
        buf.write("\31\16\31\u02de\13\31\3\31\3\31\7\31\u02e2\n\31\f\31\16")
        buf.write("\31\u02e5\13\31\3\31\3\31\3\31\5\31\u02ea\n\31\3\32\3")
        buf.write("\32\3\32\3\32\5\32\u02f0\n\32\3\32\3\32\3\32\3\32\3\32")
        buf.write("\3\32\3\32\5\32\u02f9\n\32\3\33\3\33\3\33\3\33\3\33\5")
        buf.write("\33\u0300\n\33\3\33\3\33\5\33\u0304\n\33\5\33\u0306\n")
        buf.write("\33\3\34\3\34\5\34\u030a\n\34\3\34\3\34\3\35\3\35\3\35")
        buf.write("\5\35\u0311\n\35\5\35\u0313\n\35\3\35\3\35\5\35\u0317")
        buf.write("\n\35\3\35\5\35\u031a\n\35\3\36\3\36\3\36\3\37\3\37\5")
        buf.write("\37\u0321\n\37\3\37\3\37\3\37\7\37\u0326\n\37\f\37\16")
        buf.write("\37\u0329\13\37\5\37\u032b\n\37\3\37\3\37\3\37\3\37\3")
        buf.write("\37\3\37\7\37\u0333\n\37\f\37\16\37\u0336\13\37\5\37\u0338")
        buf.write("\n\37\3\37\3\37\3\37\3\37\5\37\u033e\n\37\5\37\u0340\n")
        buf.write("\37\3 \3 \5 \u0344\n \3 \3 \3 \7 \u0349\n \f \16 \u034c")
        buf.write("\13 \5 \u034e\n \3 \3 \3 \3 \7 \u0354\n \f \16 \u0357")
        buf.write("\13 \3 \3 \3 \3 \3 \7 \u035e\n \f \16 \u0361\13 \5 \u0363")
        buf.write("\n \3 \3 \3 \3 \5 \u0369\n \5 \u036b\n \3!\3!\5!\u036f")
        buf.write("\n!\3!\3!\3!\7!\u0374\n!\f!\16!\u0377\13!\3!\3!\3!\3!")
        buf.write("\7!\u037d\n!\f!\16!\u0380\13!\3!\5!\u0383\n!\5!\u0385")
        buf.write("\n!\3!\3!\5!\u0389\n!\3!\3!\3!\3!\3!\7!\u0390\n!\f!\16")
        buf.write("!\u0393\13!\3!\3!\5!\u0397\n!\5!\u0399\n!\3!\3!\3!\3!")
        buf.write("\3!\7!\u03a0\n!\f!\16!\u03a3\13!\3!\3!\3!\3!\3!\3!\7!")
        buf.write("\u03ab\n!\f!\16!\u03ae\13!\3!\3!\7!\u03b2\n!\f!\16!\u03b5")
        buf.write("\13!\5!\u03b7\n!\3\"\5\"\u03ba\n\"\3\"\3\"\3\"\3\"\3\"")
        buf.write("\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u03c7\n\"\3\"\3\"\3\"\3\"")
        buf.write("\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u03d3\n\"\f\"\16\"\u03d6")
        buf.write("\13\"\3\"\3\"\5\"\u03da\n\"\3#\5#\u03dd\n#\3#\3#\3#\3")
        buf.write("#\3#\3#\3#\3#\3#\3#\3#\5#\u03ea\n#\3#\3#\3#\3#\3#\3#\3")
        buf.write("#\3#\3#\3#\7#\u03f6\n#\f#\16#\u03f9\13#\3#\3#\5#\u03fd")
        buf.write("\n#\3#\3#\3#\3#\3#\7#\u0404\n#\f#\16#\u0407\13#\5#\u0409")
        buf.write("\n#\3#\3#\3#\3#\5#\u040f\n#\5#\u0411\n#\3$\3$\3%\3%\5")
        buf.write("%\u0417\n%\3%\7%\u041a\n%\f%\16%\u041d\13%\3&\6&\u0420")
        buf.write("\n&\r&\16&\u0421\3&\3&\3&\3&\3&\3&\3&\3&\3&\3&\5&\u042e")
        buf.write("\n&\3\'\3\'\5\'\u0432\n\'\3\'\3\'\3\'\5\'\u0437\n\'\3")
        buf.write("\'\3\'\5\'\u043b\n\'\3\'\5\'\u043e\n\'\3\'\3\'\3\'\3\'")
        buf.write("\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u0450")
        buf.write("\n\'\3\'\3\'\3\'\5\'\u0455\n\'\3(\3(\3(\5(\u045a\n(\3")
        buf.write(")\3)\3)\3)\3)\3)\5)\u0462\n)\3)\3)\3)\5)\u0467\n)\3)\3")
        buf.write(")\3)\3)\3)\3)\3)\5)\u0470\n)\3)\3)\3)\7)\u0475\n)\f)\16")
        buf.write(")\u0478\13)\3)\5)\u047b\n)\3)\3)\3)\3)\3)\3)\3)\3)\3)")
        buf.write("\3)\3)\3)\3)\3)\5)\u048b\n)\3)\5)\u048e\n)\3)\3)\3)\3")
        buf.write(")\3)\3)\5)\u0496\n)\3)\3)\3)\3)\3)\6)\u049d\n)\r)\16)")
        buf.write("\u049e\3)\3)\5)\u04a3\n)\3)\3)\3)\5)\u04a8\n)\3)\3)\3")
        buf.write(")\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3)\3")
        buf.write(")\3)\3)\3)\3)\3)\3)\3)\5)\u04c6\n)\3)\3)\3)\3)\3)\3)\3")
        buf.write(")\3)\3)\3)\5)\u04d2\n)\3)\3)\3)\5)\u04d7\n)\3)\3)\3)\3")
        buf.write(")\3)\3)\3)\3)\3)\3)\5)\u04e3\n)\3)\3)\3)\3)\5)\u04e9\n")
        buf.write(")\3)\3)\3)\3)\3)\5)\u04f0\n)\3)\3)\5)\u04f4\n)\3)\3)\3")
        buf.write(")\3)\3)\3)\7)\u04fc\n)\f)\16)\u04ff\13)\5)\u0501\n)\3")
        buf.write(")\3)\3)\3)\5)\u0507\n)\3)\5)\u050a\n)\7)\u050c\n)\f)\16")
        buf.write(")\u050f\13)\3*\3*\3*\3*\3*\3*\7*\u0517\n*\f*\16*\u051a")
        buf.write("\13*\3*\3*\5*\u051e\n*\3*\3*\3*\3*\3*\3*\3*\3*\3*\3*\5")
        buf.write("*\u052a\n*\3*\3*\5*\u052e\n*\7*\u0530\n*\f*\16*\u0533")
        buf.write("\13*\3*\5*\u0536\n*\3*\3*\3*\3*\3*\5*\u053d\n*\5*\u053f")
        buf.write("\n*\3+\3+\3+\3+\3+\3+\5+\u0547\n+\3+\3+\3,\3,\3,\5,\u054e")
        buf.write("\n,\3,\5,\u0551\n,\3-\3-\5-\u0555\n-\3-\3-\3-\5-\u055a")
        buf.write("\n-\3-\3-\3-\3-\7-\u0560\n-\f-\16-\u0563\13-\3-\3-\3-")
        buf.write("\3-\3-\3-\3-\3-\3-\3-\3-\3-\3-\3-\7-\u0573\n-\f-\16-\u0576")
        buf.write("\13-\3-\3-\3-\5-\u057b\n-\3.\3.\5.\u057f\n.\3.\3.\3.\3")
        buf.write(".\3.\3.\3.\3.\3.\3.\3.\3.\7.\u058d\n.\f.\16.\u0590\13")
        buf.write(".\3/\3/\3/\5/\u0595\n/\3/\3/\3/\3/\3/\3/\5/\u059d\n/\3")
        buf.write("\60\3\60\3\60\5\60\u05a2\n\60\3\60\5\60\u05a5\n\60\3\61")
        buf.write("\3\61\3\61\5\61\u05aa\n\61\3\62\3\62\3\62\3\62\3\62\7")
        buf.write("\62\u05b1\n\62\f\62\16\62\u05b4\13\62\3\62\3\62\5\62\u05b8")
        buf.write("\n\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63")
        buf.write("\3\63\3\63\5\63\u05c6\n\63\3\63\5\63\u05c9\n\63\5\63\u05cb")
        buf.write("\n\63\3\64\3\64\3\64\5\64\u05d0\n\64\3\64\3\64\5\64\u05d4")
        buf.write("\n\64\3\64\5\64\u05d7\n\64\3\64\3\64\3\64\3\64\3\64\5")
        buf.write("\64\u05de\n\64\3\64\3\64\3\64\3\64\7\64\u05e4\n\64\f\64")
        buf.write("\16\64\u05e7\13\64\3\64\5\64\u05ea\n\64\3\64\3\64\5\64")
        buf.write("\u05ee\n\64\3\64\5\64\u05f1\n\64\3\64\3\64\3\64\3\64\5")
        buf.write("\64\u05f7\n\64\3\64\5\64\u05fa\n\64\5\64\u05fc\n\64\3")
        buf.write("\65\3\65\3\65\3\65\3\65\7\65\u0603\n\65\f\65\16\65\u0606")
        buf.write("\13\65\3\66\3\66\5\66\u060a\n\66\3\66\3\66\5\66\u060e")
        buf.write("\n\66\3\66\3\66\5\66\u0612\n\66\3\66\5\66\u0615\n\66\3")
        buf.write("\67\3\67\3\67\3\67\3\67\3\67\3\67\7\67\u061e\n\67\f\67")
        buf.write("\16\67\u0621\13\67\3\67\3\67\5\67\u0625\n\67\38\38\58")
        buf.write("\u0629\n8\38\38\38\78\u062e\n8\f8\168\u0631\138\38\38")
        buf.write("\38\38\78\u0637\n8\f8\168\u063a\138\38\58\u063d\n8\58")
        buf.write("\u063f\n8\38\38\58\u0643\n8\38\38\38\38\38\78\u064a\n")
        buf.write("8\f8\168\u064d\138\38\38\58\u0651\n8\58\u0653\n8\38\3")
        buf.write("8\38\38\38\78\u065a\n8\f8\168\u065d\138\38\38\38\38\3")
        buf.write("8\38\78\u0665\n8\f8\168\u0668\138\38\38\78\u066c\n8\f")
        buf.write("8\168\u066f\138\58\u0671\n8\39\39\39\39\39\59\u0678\n")
        buf.write("9\3:\3:\3:\3:\3:\7:\u067f\n:\f:\16:\u0682\13:\3:\3:\5")
        buf.write(":\u0686\n:\3;\5;\u0689\n;\3;\3;\3<\3<\3=\3=\3>\3>\3?\3")
        buf.write("?\5?\u0695\n?\3@\3@\3A\3A\3B\3B\3C\3C\3D\3D\3E\3E\3F\3")
        buf.write("F\3G\3G\3H\3H\3I\3I\3J\3J\3K\3K\3L\3L\3M\3M\3N\3N\3O\3")
        buf.write("O\3P\3P\3Q\3Q\3R\3R\3S\3S\3S\3S\3S\3S\3S\5S\u06c4\nS\3")
        buf.write("S\2\3PT\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*")
        buf.write(",.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080")
        buf.write("\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092")
        buf.write("\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4")
        buf.write("\2\24\5\2<<GGTT\4\2\61\61DD\4\2\7\7ll\3\2\u0085\u0086")
        buf.write("\4\2\37\37@@\4\2$$>>\7\2\33\33JJSS||\177\177\4\2\t\t\16")
        buf.write("\17\3\2\n\13\3\2\20\23\3\2\24\27\6\2OOcceexx\4\2==\u008d")
        buf.write("\u008d\5\2\33\33JJ\177\177\6\2\668jj\u0098\u0098\u009a")
        buf.write("\u009b\4\2\n\fhh\4\2\u0097\u0097\u009a\u009a\3\2\33\u0096")
        buf.write("\2\u07d3\2\u00aa\3\2\2\2\4\u00af\3\2\2\2\6\u00b5\3\2\2")
        buf.write("\2\b\u00cf\3\2\2\2\n\u00f1\3\2\2\2\f\u0103\3\2\2\2\16")
        buf.write("\u010c\3\2\2\2\20\u0114\3\2\2\2\22\u011e\3\2\2\2\24\u0131")
        buf.write("\3\2\2\2\26\u0155\3\2\2\2\30\u0175\3\2\2\2\32\u019e\3")
        buf.write("\2\2\2\34\u01e3\3\2\2\2\36\u01f6\3\2\2\2 \u0214\3\2\2")
        buf.write("\2\"\u021e\3\2\2\2$\u023b\3\2\2\2&\u0241\3\2\2\2(\u024e")
        buf.write("\3\2\2\2*\u025b\3\2\2\2,\u0268\3\2\2\2.\u0281\3\2\2\2")
        buf.write("\60\u02a1\3\2\2\2\62\u02eb\3\2\2\2\64\u02fa\3\2\2\2\66")
        buf.write("\u0307\3\2\2\28\u030d\3\2\2\2:\u031b\3\2\2\2<\u032a\3")
        buf.write("\2\2\2>\u034d\3\2\2\2@\u03b6\3\2\2\2B\u03b9\3\2\2\2D\u03dc")
        buf.write("\3\2\2\2F\u0412\3\2\2\2H\u0414\3\2\2\2J\u041f\3\2\2\2")
        buf.write("L\u0431\3\2\2\2N\u0459\3\2\2\2P\u04a7\3\2\2\2R\u0510\3")
        buf.write("\2\2\2T\u0540\3\2\2\2V\u054a\3\2\2\2X\u0554\3\2\2\2Z\u057c")
        buf.write("\3\2\2\2\\\u0594\3\2\2\2^\u059e\3\2\2\2`\u05a9\3\2\2\2")
        buf.write("b\u05ab\3\2\2\2d\u05ca\3\2\2\2f\u05fb\3\2\2\2h\u05fd\3")
        buf.write("\2\2\2j\u0614\3\2\2\2l\u0624\3\2\2\2n\u0670\3\2\2\2p\u0677")
        buf.write("\3\2\2\2r\u0679\3\2\2\2t\u0688\3\2\2\2v\u068c\3\2\2\2")
        buf.write("x\u068e\3\2\2\2z\u0690\3\2\2\2|\u0694\3\2\2\2~\u0696\3")
        buf.write("\2\2\2\u0080\u0698\3\2\2\2\u0082\u069a\3\2\2\2\u0084\u069c")
        buf.write("\3\2\2\2\u0086\u069e\3\2\2\2\u0088\u06a0\3\2\2\2\u008a")
        buf.write("\u06a2\3\2\2\2\u008c\u06a4\3\2\2\2\u008e\u06a6\3\2\2\2")
        buf.write("\u0090\u06a8\3\2\2\2\u0092\u06aa\3\2\2\2\u0094\u06ac\3")
        buf.write("\2\2\2\u0096\u06ae\3\2\2\2\u0098\u06b0\3\2\2\2\u009a\u06b2")
        buf.write("\3\2\2\2\u009c\u06b4\3\2\2\2\u009e\u06b6\3\2\2\2\u00a0")
        buf.write("\u06b8\3\2\2\2\u00a2\u06ba\3\2\2\2\u00a4\u06c3\3\2\2\2")
        buf.write("\u00a6\u00a9\5\6\4\2\u00a7\u00a9\5\4\3\2\u00a8\u00a6\3")
        buf.write("\2\2\2\u00a8\u00a7\3\2\2\2\u00a9\u00ac\3\2\2\2\u00aa\u00a8")
        buf.write("\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\u00ad\3\2\2\2\u00ac")
        buf.write("\u00aa\3\2\2\2\u00ad\u00ae\7\2\2\3\u00ae\3\3\2\2\2\u00af")
        buf.write("\u00b0\7\u009f\2\2\u00b0\u00b1\b\3\1\2\u00b1\5\3\2\2\2")
        buf.write("\u00b2\u00b4\7\3\2\2\u00b3\u00b2\3\2\2\2\u00b4\u00b7\3")
        buf.write("\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00b8")
        buf.write("\3\2\2\2\u00b7\u00b5\3\2\2\2\u00b8\u00c1\5\b\5\2\u00b9")
        buf.write("\u00bb\7\3\2\2\u00ba\u00b9\3\2\2\2\u00bb\u00bc\3\2\2\2")
        buf.write("\u00bc\u00ba\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd\u00be\3")
        buf.write("\2\2\2\u00be\u00c0\5\b\5\2\u00bf\u00ba\3\2\2\2\u00c0\u00c3")
        buf.write("\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2")
        buf.write("\u00c7\3\2\2\2\u00c3\u00c1\3\2\2\2\u00c4\u00c6\7\3\2\2")
        buf.write("\u00c5\u00c4\3\2\2\2\u00c6\u00c9\3\2\2\2\u00c7\u00c5\3")
        buf.write("\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\7\3\2\2\2\u00c9\u00c7")
        buf.write("\3\2\2\2\u00ca\u00cd\7I\2\2\u00cb\u00cc\7t\2\2\u00cc\u00ce")
        buf.write("\7q\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce")
        buf.write("\u00d0\3\2\2\2\u00cf\u00ca\3\2\2\2\u00cf\u00d0\3\2\2\2")
        buf.write("\u00d0\u00ef\3\2\2\2\u00d1\u00f0\5\n\6\2\u00d2\u00f0\5")
        buf.write("\f\7\2\u00d3\u00f0\5\16\b\2\u00d4\u00f0\5\20\t\2\u00d5")
        buf.write("\u00f0\5\22\n\2\u00d6\u00f0\5\24\13\2\u00d7\u00f0\5\26")
        buf.write("\f\2\u00d8\u00f0\5\30\r\2\u00d9\u00f0\5\32\16\2\u00da")
        buf.write("\u00f0\5\34\17\2\u00db\u00f0\5\36\20\2\u00dc\u00f0\5 ")
        buf.write("\21\2\u00dd\u00f0\5\"\22\2\u00de\u00f0\5$\23\2\u00df\u00f0")
        buf.write("\5&\24\2\u00e0\u00f0\5(\25\2\u00e1\u00f0\5*\26\2\u00e2")
        buf.write("\u00f0\5,\27\2\u00e3\u00f0\5.\30\2\u00e4\u00f0\5\60\31")
        buf.write("\2\u00e5\u00f0\5\62\32\2\u00e6\u00f0\5\64\33\2\u00e7\u00f0")
        buf.write("\5\66\34\2\u00e8\u00f0\58\35\2\u00e9\u00f0\5:\36\2\u00ea")
        buf.write("\u00f0\5<\37\2\u00eb\u00f0\5> \2\u00ec\u00f0\5B\"\2\u00ed")
        buf.write("\u00f0\5D#\2\u00ee\u00f0\5F$\2\u00ef\u00d1\3\2\2\2\u00ef")
        buf.write("\u00d2\3\2\2\2\u00ef\u00d3\3\2\2\2\u00ef\u00d4\3\2\2\2")
        buf.write("\u00ef\u00d5\3\2\2\2\u00ef\u00d6\3\2\2\2\u00ef\u00d7\3")
        buf.write("\2\2\2\u00ef\u00d8\3\2\2\2\u00ef\u00d9\3\2\2\2\u00ef\u00da")
        buf.write("\3\2\2\2\u00ef\u00db\3\2\2\2\u00ef\u00dc\3\2\2\2\u00ef")
        buf.write("\u00dd\3\2\2\2\u00ef\u00de\3\2\2\2\u00ef\u00df\3\2\2\2")
        buf.write("\u00ef\u00e0\3\2\2\2\u00ef\u00e1\3\2\2\2\u00ef\u00e2\3")
        buf.write("\2\2\2\u00ef\u00e3\3\2\2\2\u00ef\u00e4\3\2\2\2\u00ef\u00e5")
        buf.write("\3\2\2\2\u00ef\u00e6\3\2\2\2\u00ef\u00e7\3\2\2\2\u00ef")
        buf.write("\u00e8\3\2\2\2\u00ef\u00e9\3\2\2\2\u00ef\u00ea\3\2\2\2")
        buf.write("\u00ef\u00eb\3\2\2\2\u00ef\u00ec\3\2\2\2\u00ef\u00ed\3")
        buf.write("\2\2\2\u00ef\u00ee\3\2\2\2\u00f0\t\3\2\2\2\u00f1\u00f2")
        buf.write("\7 \2\2\u00f2\u00f6\7\u0084\2\2\u00f3\u00f4\5\u0086D\2")
        buf.write("\u00f4\u00f5\7\4\2\2\u00f5\u00f7\3\2\2\2\u00f6\u00f3\3")
        buf.write("\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u0101")
        buf.write("\5\u0088E\2\u00f9\u00fa\7{\2\2\u00fa\u00fb\7\u0088\2\2")
        buf.write("\u00fb\u0102\5\u008cG\2\u00fc\u00fe\7\35\2\2\u00fd\u00ff")
        buf.write("\7\60\2\2\u00fe\u00fd\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff")
        buf.write("\u0100\3\2\2\2\u0100\u0102\5H%\2\u0101\u00f9\3\2\2\2\u0101")
        buf.write("\u00fc\3\2\2\2\u0102\13\3\2\2\2\u0103\u010a\7!\2\2\u0104")
        buf.write("\u010b\5\u0086D\2\u0105\u010b\5\u008aF\2\u0106\u0107\5")
        buf.write("\u0086D\2\u0107\u0108\7\4\2\2\u0108\u0109\5\u008aF\2\u0109")
        buf.write("\u010b\3\2\2\2\u010a\u0104\3\2\2\2\u010a\u0105\3\2\2\2")
        buf.write("\u010a\u0106\3\2\2\2\u010a\u010b\3\2\2\2\u010b\r\3\2\2")
        buf.write("\2\u010c\u010e\7%\2\2\u010d\u010f\79\2\2\u010e\u010d\3")
        buf.write("\2\2\2\u010e\u010f\3\2\2\2\u010f\u0110\3\2\2\2\u0110\u0111")
        buf.write("\5P)\2\u0111\u0112\7#\2\2\u0112\u0113\5\u0086D\2\u0113")
        buf.write("\17\3\2\2\2\u0114\u0116\7(\2\2\u0115\u0117\t\2\2\2\u0116")
        buf.write("\u0115\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u011c\3\2\2\2")
        buf.write("\u0118\u011a\7\u0089\2\2\u0119\u011b\5\u00a2R\2\u011a")
        buf.write("\u0119\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u011d\3\2\2\2")
        buf.write("\u011c\u0118\3\2\2\2\u011c\u011d\3\2\2\2\u011d\21\3\2")
        buf.write("\2\2\u011e\u0123\t\3\2\2\u011f\u0121\7\u0089\2\2\u0120")
        buf.write("\u0122\5\u00a2R\2\u0121\u0120\3\2\2\2\u0121\u0122\3\2")
        buf.write("\2\2\u0122\u0124\3\2\2\2\u0123\u011f\3\2\2\2\u0123\u0124")
        buf.write("\3\2\2\2\u0124\23\3\2\2\2\u0125\u0127\7\u0095\2\2\u0126")
        buf.write("\u0128\7v\2\2\u0127\u0126\3\2\2\2\u0127\u0128\3\2\2\2")
        buf.write("\u0128\u0129\3\2\2\2\u0129\u012e\5b\62\2\u012a\u012b\7")
        buf.write("\7\2\2\u012b\u012d\5b\62\2\u012c\u012a\3\2\2\2\u012d\u0130")
        buf.write("\3\2\2\2\u012e\u012c\3\2\2\2\u012e\u012f\3\2\2\2\u012f")
        buf.write("\u0132\3\2\2\2\u0130\u012e\3\2\2\2\u0131\u0125\3\2\2\2")
        buf.write("\u0131\u0132\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u013d\5")
        buf.write("n8\2\u0134\u0136\7\u008b\2\2\u0135\u0137\7\37\2\2\u0136")
        buf.write("\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u013b\3\2\2\2")
        buf.write("\u0138\u013b\7\\\2\2\u0139\u013b\7F\2\2\u013a\u0134\3")
        buf.write("\2\2\2\u013a\u0138\3\2\2\2\u013a\u0139\3\2\2\2\u013b\u013c")
        buf.write("\3\2\2\2\u013c\u013e\5n8\2\u013d\u013a\3\2\2\2\u013e\u013f")
        buf.write("\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3\2\2\2\u0140")
        buf.write("\u014b\3\2\2\2\u0141\u0142\7o\2\2\u0142\u0143\7*\2\2\u0143")
        buf.write("\u0148\5^\60\2\u0144\u0145\7\7\2\2\u0145\u0147\5^\60\2")
        buf.write("\u0146\u0144\3\2\2\2\u0147\u014a\3\2\2\2\u0148\u0146\3")
        buf.write("\2\2\2\u0148\u0149\3\2\2\2\u0149\u014c\3\2\2\2\u014a\u0148")
        buf.write("\3\2\2\2\u014b\u0141\3\2\2\2\u014b\u014c\3\2\2\2\u014c")
        buf.write("\u0153\3\2\2\2\u014d\u014e\7d\2\2\u014e\u0151\5P)\2\u014f")
        buf.write("\u0150\t\4\2\2\u0150\u0152\5P)\2\u0151\u014f\3\2\2\2\u0151")
        buf.write("\u0152\3\2\2\2\u0152\u0154\3\2\2\2\u0153\u014d\3\2\2\2")
        buf.write("\u0153\u0154\3\2\2\2\u0154\25\3\2\2\2\u0155\u0157\7\64")
        buf.write("\2\2\u0156\u0158\7\u008c\2\2\u0157\u0156\3\2\2\2\u0157")
        buf.write("\u0158\3\2\2\2\u0158\u0159\3\2\2\2\u0159\u015d\7V\2\2")
        buf.write("\u015a\u015b\7R\2\2\u015b\u015c\7h\2\2\u015c\u015e\7H")
        buf.write("\2\2\u015d\u015a\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u0162")
        buf.write("\3\2\2\2\u015f\u0160\5\u0086D\2\u0160\u0161\7\4\2\2\u0161")
        buf.write("\u0163\3\2\2\2\u0162\u015f\3\2\2\2\u0162\u0163\3\2\2\2")
        buf.write("\u0163\u0164\3\2\2\2\u0164\u0165\5\u0094K\2\u0165\u0166")
        buf.write("\7m\2\2\u0166\u0167\5\u0088E\2\u0167\u0168\7\5\2\2\u0168")
        buf.write("\u016d\5V,\2\u0169\u016a\7\7\2\2\u016a\u016c\5V,\2\u016b")
        buf.write("\u0169\3\2\2\2\u016c\u016f\3\2\2\2\u016d\u016b\3\2\2\2")
        buf.write("\u016d\u016e\3\2\2\2\u016e\u0170\3\2\2\2\u016f\u016d\3")
        buf.write("\2\2\2\u0170\u0173\7\6\2\2\u0171\u0172\7\u0094\2\2\u0172")
        buf.write("\u0174\5P)\2\u0173\u0171\3\2\2\2\u0173\u0174\3\2\2\2\u0174")
        buf.write("\27\3\2\2\2\u0175\u0177\7\64\2\2\u0176\u0178\t\5\2\2\u0177")
        buf.write("\u0176\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u0179\3\2\2\2")
        buf.write("\u0179\u017d\7\u0084\2\2\u017a\u017b\7R\2\2\u017b\u017c")
        buf.write("\7h\2\2\u017c\u017e\7H\2\2\u017d\u017a\3\2\2\2\u017d\u017e")
        buf.write("\3\2\2\2\u017e\u0182\3\2\2\2\u017f\u0180\5\u0086D\2\u0180")
        buf.write("\u0181\7\4\2\2\u0181\u0183\3\2\2\2\u0182\u017f\3\2\2\2")
        buf.write("\u0182\u0183\3\2\2\2\u0183\u0184\3\2\2\2\u0184\u019c\5")
        buf.write("\u0088E\2\u0185\u0186\7\5\2\2\u0186\u018b\5H%\2\u0187")
        buf.write("\u0188\7\7\2\2\u0188\u018a\5H%\2\u0189\u0187\3\2\2\2\u018a")
        buf.write("\u018d\3\2\2\2\u018b\u0189\3\2\2\2\u018b\u018c\3\2\2\2")
        buf.write("\u018c\u0192\3\2\2\2\u018d\u018b\3\2\2\2\u018e\u018f\7")
        buf.write("\7\2\2\u018f\u0191\5X-\2\u0190\u018e\3\2\2\2\u0191\u0194")
        buf.write("\3\2\2\2\u0192\u0190\3\2\2\2\u0192\u0193\3\2\2\2\u0193")
        buf.write("\u0195\3\2\2\2\u0194\u0192\3\2\2\2\u0195\u0198\7\6\2\2")
        buf.write("\u0196\u0197\7\u0096\2\2\u0197\u0199\7\u0097\2\2\u0198")
        buf.write("\u0196\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019d\3\2\2\2")
        buf.write("\u019a\u019b\7#\2\2\u019b\u019d\5> \2\u019c\u0185\3\2")
        buf.write("\2\2\u019c\u019a\3\2\2\2\u019d\31\3\2\2\2\u019e\u01a0")
        buf.write("\7\64\2\2\u019f\u01a1\t\5\2\2\u01a0\u019f\3\2\2\2\u01a0")
        buf.write("\u01a1\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01a6\7\u008a")
        buf.write("\2\2\u01a3\u01a4\7R\2\2\u01a4\u01a5\7h\2\2\u01a5\u01a7")
        buf.write("\7H\2\2\u01a6\u01a3\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7")
        buf.write("\u01ab\3\2\2\2\u01a8\u01a9\5\u0086D\2\u01a9\u01aa\7\4")
        buf.write("\2\2\u01aa\u01ac\3\2\2\2\u01ab\u01a8\3\2\2\2\u01ab\u01ac")
        buf.write("\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\u01b2\5\u0096L\2\u01ae")
        buf.write("\u01b3\7\'\2\2\u01af\u01b3\7\36\2\2\u01b0\u01b1\7[\2\2")
        buf.write("\u01b1\u01b3\7k\2\2\u01b2\u01ae\3\2\2\2\u01b2\u01af\3")
        buf.write("\2\2\2\u01b2\u01b0\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3\u01c2")
        buf.write("\3\2\2\2\u01b4\u01c3\7=\2\2\u01b5\u01c3\7Z\2\2\u01b6\u01c0")
        buf.write("\7\u008d\2\2\u01b7\u01b8\7k\2\2\u01b8\u01bd\5\u008eH\2")
        buf.write("\u01b9\u01ba\7\7\2\2\u01ba\u01bc\5\u008eH\2\u01bb\u01b9")
        buf.write("\3\2\2\2\u01bc\u01bf\3\2\2\2\u01bd\u01bb\3\2\2\2\u01bd")
        buf.write("\u01be\3\2\2\2\u01be\u01c1\3\2\2\2\u01bf\u01bd\3\2\2\2")
        buf.write("\u01c0\u01b7\3\2\2\2\u01c0\u01c1\3\2\2\2\u01c1\u01c3\3")
        buf.write("\2\2\2\u01c2\u01b4\3\2\2\2\u01c2\u01b5\3\2\2\2\u01c2\u01b6")
        buf.write("\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01c8\7m\2\2\u01c5")
        buf.write("\u01c6\5\u0086D\2\u01c6\u01c7\7\4\2\2\u01c7\u01c9\3\2")
        buf.write("\2\2\u01c8\u01c5\3\2\2\2\u01c8\u01c9\3\2\2\2\u01c9\u01ca")
        buf.write("\3\2\2\2\u01ca\u01ce\5\u0088E\2\u01cb\u01cc\7K\2\2\u01cc")
        buf.write("\u01cd\7B\2\2\u01cd\u01cf\7\u0080\2\2\u01ce\u01cb\3\2")
        buf.write("\2\2\u01ce\u01cf\3\2\2\2\u01cf\u01d2\3\2\2\2\u01d0\u01d1")
        buf.write("\7\u0093\2\2\u01d1\u01d3\5P)\2\u01d2\u01d0\3\2\2\2\u01d2")
        buf.write("\u01d3\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01dd\7(\2\2")
        buf.write("\u01d5\u01da\5B\"\2\u01d6\u01da\5\60\31\2\u01d7\u01da")
        buf.write("\5 \21\2\u01d8\u01da\5> \2\u01d9\u01d5\3\2\2\2\u01d9\u01d6")
        buf.write("\3\2\2\2\u01d9\u01d7\3\2\2\2\u01d9\u01d8\3\2\2\2\u01da")
        buf.write("\u01db\3\2\2\2\u01db\u01dc\7\3\2\2\u01dc\u01de\3\2\2\2")
        buf.write("\u01dd\u01d9\3\2\2\2\u01de\u01df\3\2\2\2\u01df\u01dd\3")
        buf.write("\2\2\2\u01df\u01e0\3\2\2\2\u01e0\u01e1\3\2\2\2\u01e1\u01e2")
        buf.write("\7D\2\2\u01e2\33\3\2\2\2\u01e3\u01e5\7\64\2\2\u01e4\u01e6")
        buf.write("\t\5\2\2\u01e5\u01e4\3\2\2\2\u01e5\u01e6\3\2\2\2\u01e6")
        buf.write("\u01e7\3\2\2\2\u01e7\u01eb\7\u0091\2\2\u01e8\u01e9\7R")
        buf.write("\2\2\u01e9\u01ea\7h\2\2\u01ea\u01ec\7H\2\2\u01eb\u01e8")
        buf.write("\3\2\2\2\u01eb\u01ec\3\2\2\2\u01ec\u01f0\3\2\2\2\u01ed")
        buf.write("\u01ee\5\u0086D\2\u01ee\u01ef\7\4\2\2\u01ef\u01f1\3\2")
        buf.write("\2\2\u01f0\u01ed\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1\u01f2")
        buf.write("\3\2\2\2\u01f2\u01f3\5\u0098M\2\u01f3\u01f4\7#\2\2\u01f4")
        buf.write("\u01f5\5> \2\u01f5\35\3\2\2\2\u01f6\u01f7\7\64\2\2\u01f7")
        buf.write("\u01f8\7\u0092\2\2\u01f8\u01fc\7\u0084\2\2\u01f9\u01fa")
        buf.write("\7R\2\2\u01fa\u01fb\7h\2\2\u01fb\u01fd\7H\2\2\u01fc\u01f9")
        buf.write("\3\2\2\2\u01fc\u01fd\3\2\2\2\u01fd\u0201\3\2\2\2\u01fe")
        buf.write("\u01ff\5\u0086D\2\u01ff\u0200\7\4\2\2\u0200\u0202\3\2")
        buf.write("\2\2\u0201\u01fe\3\2\2\2\u0201\u0202\3\2\2\2\u0202\u0203")
        buf.write("\3\2\2\2\u0203\u0204\5\u0088E\2\u0204\u0205\7\u008e\2")
        buf.write("\2\u0205\u0211\5\u009aN\2\u0206\u0207\7\5\2\2\u0207\u020c")
        buf.write("\5|?\2\u0208\u0209\7\7\2\2\u0209\u020b\5|?\2\u020a\u0208")
        buf.write("\3\2\2\2\u020b\u020e\3\2\2\2\u020c\u020a\3\2\2\2\u020c")
        buf.write("\u020d\3\2\2\2\u020d\u020f\3\2\2\2\u020e\u020c\3\2\2\2")
        buf.write("\u020f\u0210\7\6\2\2\u0210\u0212\3\2\2\2\u0211\u0206\3")
        buf.write("\2\2\2\u0211\u0212\3\2\2\2\u0212\37\3\2\2\2\u0213\u0215")
        buf.write("\5Z.\2\u0214\u0213\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0216")
        buf.write("\3\2\2\2\u0216\u0217\7=\2\2\u0217\u0218\7M\2\2\u0218\u021b")
        buf.write("\5\\/\2\u0219\u021a\7\u0094\2\2\u021a\u021c\5P)\2\u021b")
        buf.write("\u0219\3\2\2\2\u021b\u021c\3\2\2\2\u021c!\3\2\2\2\u021d")
        buf.write("\u021f\5Z.\2\u021e\u021d\3\2\2\2\u021e\u021f\3\2\2\2\u021f")
        buf.write("\u0220\3\2\2\2\u0220\u0221\7=\2\2\u0221\u0222\7M\2\2\u0222")
        buf.write("\u0225\5\\/\2\u0223\u0224\7\u0094\2\2\u0224\u0226\5P)")
        buf.write("\2\u0225\u0223\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0239")
        buf.write("\3\2\2\2\u0227\u0228\7o\2\2\u0228\u0229\7*\2\2\u0229\u022e")
        buf.write("\5^\60\2\u022a\u022b\7\7\2\2\u022b\u022d\5^\60\2\u022c")
        buf.write("\u022a\3\2\2\2\u022d\u0230\3\2\2\2\u022e\u022c\3\2\2\2")
        buf.write("\u022e\u022f\3\2\2\2\u022f\u0232\3\2\2\2\u0230\u022e\3")
        buf.write("\2\2\2\u0231\u0227\3\2\2\2\u0231\u0232\3\2\2\2\u0232\u0233")
        buf.write("\3\2\2\2\u0233\u0234\7d\2\2\u0234\u0237\5P)\2\u0235\u0236")
        buf.write("\t\4\2\2\u0236\u0238\5P)\2\u0237\u0235\3\2\2\2\u0237\u0238")
        buf.write("\3\2\2\2\u0238\u023a\3\2\2\2\u0239\u0231\3\2\2\2\u0239")
        buf.write("\u023a\3\2\2\2\u023a#\3\2\2\2\u023b\u023d\7?\2\2\u023c")
        buf.write("\u023e\79\2\2\u023d\u023c\3\2\2\2\u023d\u023e\3\2\2\2")
        buf.write("\u023e\u023f\3\2\2\2\u023f\u0240\5\u0086D\2\u0240%\3\2")
        buf.write("\2\2\u0241\u0242\7A\2\2\u0242\u0245\7V\2\2\u0243\u0244")
        buf.write("\7R\2\2\u0244\u0246\7H\2\2\u0245\u0243\3\2\2\2\u0245\u0246")
        buf.write("\3\2\2\2\u0246\u024a\3\2\2\2\u0247\u0248\5\u0086D\2\u0248")
        buf.write("\u0249\7\4\2\2\u0249\u024b\3\2\2\2\u024a\u0247\3\2\2\2")
        buf.write("\u024a\u024b\3\2\2\2\u024b\u024c\3\2\2\2\u024c\u024d\5")
        buf.write("\u0094K\2\u024d\'\3\2\2\2\u024e\u024f\7A\2\2\u024f\u0252")
        buf.write("\7\u0084\2\2\u0250\u0251\7R\2\2\u0251\u0253\7H\2\2\u0252")
        buf.write("\u0250\3\2\2\2\u0252\u0253\3\2\2\2\u0253\u0257\3\2\2\2")
        buf.write("\u0254\u0255\5\u0086D\2\u0255\u0256\7\4\2\2\u0256\u0258")
        buf.write("\3\2\2\2\u0257\u0254\3\2\2\2\u0257\u0258\3\2\2\2\u0258")
        buf.write("\u0259\3\2\2\2\u0259\u025a\5\u0088E\2\u025a)\3\2\2\2\u025b")
        buf.write("\u025c\7A\2\2\u025c\u025f\7\u008a\2\2\u025d\u025e\7R\2")
        buf.write("\2\u025e\u0260\7H\2\2\u025f\u025d\3\2\2\2\u025f\u0260")
        buf.write("\3\2\2\2\u0260\u0264\3\2\2\2\u0261\u0262\5\u0086D\2\u0262")
        buf.write("\u0263\7\4\2\2\u0263\u0265\3\2\2\2\u0264\u0261\3\2\2\2")
        buf.write("\u0264\u0265\3\2\2\2\u0265\u0266\3\2\2\2\u0266\u0267\5")
        buf.write("\u0096L\2\u0267+\3\2\2\2\u0268\u0269\7A\2\2\u0269\u026c")
        buf.write("\7\u0091\2\2\u026a\u026b\7R\2\2\u026b\u026d\7H\2\2\u026c")
        buf.write("\u026a\3\2\2\2\u026c\u026d\3\2\2\2\u026d\u0271\3\2\2\2")
        buf.write("\u026e\u026f\5\u0086D\2\u026f\u0270\7\4\2\2\u0270\u0272")
        buf.write("\3\2\2\2\u0271\u026e\3\2\2\2\u0271\u0272\3\2\2\2\u0272")
        buf.write("\u0273\3\2\2\2\u0273\u0274\5\u0098M\2\u0274-\3\2\2\2\u0275")
        buf.write("\u0277\7\u0095\2\2\u0276\u0278\7v\2\2\u0277\u0276\3\2")
        buf.write("\2\2\u0277\u0278\3\2\2\2\u0278\u0279\3\2\2\2\u0279\u027e")
        buf.write("\5b\62\2\u027a\u027b\7\7\2\2\u027b\u027d\5b\62\2\u027c")
        buf.write("\u027a\3\2\2\2\u027d\u0280\3\2\2\2\u027e\u027c\3\2\2\2")
        buf.write("\u027e\u027f\3\2\2\2\u027f\u0282\3\2\2\2\u0280\u027e\3")
        buf.write("\2\2\2\u0281\u0275\3\2\2\2\u0281\u0282\3\2\2\2\u0282\u0283")
        buf.write("\3\2\2\2\u0283\u0289\5n8\2\u0284\u0285\5p9\2\u0285\u0286")
        buf.write("\5n8\2\u0286\u0288\3\2\2\2\u0287\u0284\3\2\2\2\u0288\u028b")
        buf.write("\3\2\2\2\u0289\u0287\3\2\2\2\u0289\u028a\3\2\2\2\u028a")
        buf.write("\u0296\3\2\2\2\u028b\u0289\3\2\2\2\u028c\u028d\7o\2\2")
        buf.write("\u028d\u028e\7*\2\2\u028e\u0293\5^\60\2\u028f\u0290\7")
        buf.write("\7\2\2\u0290\u0292\5^\60\2\u0291\u028f\3\2\2\2\u0292\u0295")
        buf.write("\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0294\3\2\2\2\u0294")
        buf.write("\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0296\u028c\3\2\2\2")
        buf.write("\u0296\u0297\3\2\2\2\u0297\u029e\3\2\2\2\u0298\u0299\7")
        buf.write("d\2\2\u0299\u029c\5P)\2\u029a\u029b\t\4\2\2\u029b\u029d")
        buf.write("\5P)\2\u029c\u029a\3\2\2\2\u029c\u029d\3\2\2\2\u029d\u029f")
        buf.write("\3\2\2\2\u029e\u0298\3\2\2\2\u029e\u029f\3\2\2\2\u029f")
        buf.write("/\3\2\2\2\u02a0\u02a2\5Z.\2\u02a1\u02a0\3\2\2\2\u02a1")
        buf.write("\u02a2\3\2\2\2\u02a2\u02b4\3\2\2\2\u02a3\u02b5\7Z\2\2")
        buf.write("\u02a4\u02b5\7|\2\2\u02a5\u02a6\7Z\2\2\u02a6\u02a7\7n")
        buf.write("\2\2\u02a7\u02b5\7|\2\2\u02a8\u02a9\7Z\2\2\u02a9\u02aa")
        buf.write("\7n\2\2\u02aa\u02b5\7\177\2\2\u02ab\u02ac\7Z\2\2\u02ac")
        buf.write("\u02ad\7n\2\2\u02ad\u02b5\7\33\2\2\u02ae\u02af\7Z\2\2")
        buf.write("\u02af\u02b0\7n\2\2\u02b0\u02b5\7J\2\2\u02b1\u02b2\7Z")
        buf.write("\2\2\u02b2\u02b3\7n\2\2\u02b3\u02b5\7S\2\2\u02b4\u02a3")
        buf.write("\3\2\2\2\u02b4\u02a4\3\2\2\2\u02b4\u02a5\3\2\2\2\u02b4")
        buf.write("\u02a8\3\2\2\2\u02b4\u02ab\3\2\2\2\u02b4\u02ae\3\2\2\2")
        buf.write("\u02b4\u02b1\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6\u02ba\7")
        buf.write("]\2\2\u02b7\u02b8\5\u0086D\2\u02b8\u02b9\7\4\2\2\u02b9")
        buf.write("\u02bb\3\2\2\2\u02ba\u02b7\3\2\2\2\u02ba\u02bb\3\2\2\2")
        buf.write("\u02bb\u02bc\3\2\2\2\u02bc\u02c8\5\u0088E\2\u02bd\u02be")
        buf.write("\7\5\2\2\u02be\u02c3\5\u008eH\2\u02bf\u02c0\7\7\2\2\u02c0")
        buf.write("\u02c2\5\u008eH\2\u02c1\u02bf\3\2\2\2\u02c2\u02c5\3\2")
        buf.write("\2\2\u02c3\u02c1\3\2\2\2\u02c3\u02c4\3\2\2\2\u02c4\u02c6")
        buf.write("\3\2\2\2\u02c5\u02c3\3\2\2\2\u02c6\u02c7\7\6\2\2\u02c7")
        buf.write("\u02c9\3\2\2\2\u02c8\u02bd\3\2\2\2\u02c8\u02c9\3\2\2\2")
        buf.write("\u02c9\u02e9\3\2\2\2\u02ca\u02cb\7\u0090\2\2\u02cb\u02cc")
        buf.write("\7\5\2\2\u02cc\u02d1\5P)\2\u02cd\u02ce\7\7\2\2\u02ce\u02d0")
        buf.write("\5P)\2\u02cf\u02cd\3\2\2\2\u02d0\u02d3\3\2\2\2\u02d1\u02cf")
        buf.write("\3\2\2\2\u02d1\u02d2\3\2\2\2\u02d2\u02d4\3\2\2\2\u02d3")
        buf.write("\u02d1\3\2\2\2\u02d4\u02e3\7\6\2\2\u02d5\u02d6\7\7\2\2")
        buf.write("\u02d6\u02d7\7\5\2\2\u02d7\u02dc\5P)\2\u02d8\u02d9\7\7")
        buf.write("\2\2\u02d9\u02db\5P)\2\u02da\u02d8\3\2\2\2\u02db\u02de")
        buf.write("\3\2\2\2\u02dc\u02da\3\2\2\2\u02dc\u02dd\3\2\2\2\u02dd")
        buf.write("\u02df\3\2\2\2\u02de\u02dc\3\2\2\2\u02df\u02e0\7\6\2\2")
        buf.write("\u02e0\u02e2\3\2\2\2\u02e1\u02d5\3\2\2\2\u02e2\u02e5\3")
        buf.write("\2\2\2\u02e3\u02e1\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02ea")
        buf.write("\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e6\u02ea\5> \2\u02e7\u02e8")
        buf.write("\7:\2\2\u02e8\u02ea\7\u0090\2\2\u02e9\u02ca\3\2\2\2\u02e9")
        buf.write("\u02e6\3\2\2\2\u02e9\u02e7\3\2\2\2\u02ea\61\3\2\2\2\u02eb")
        buf.write("\u02ef\7r\2\2\u02ec\u02ed\5\u0086D\2\u02ed\u02ee\7\4\2")
        buf.write("\2\u02ee\u02f0\3\2\2\2\u02ef\u02ec\3\2\2\2\u02ef\u02f0")
        buf.write("\3\2\2\2\u02f0\u02f1\3\2\2\2\u02f1\u02f8\5\u009cO\2\u02f2")
        buf.write("\u02f3\7\b\2\2\u02f3\u02f9\5`\61\2\u02f4\u02f5\7\5\2\2")
        buf.write("\u02f5\u02f6\5`\61\2\u02f6\u02f7\7\6\2\2\u02f7\u02f9\3")
        buf.write("\2\2\2\u02f8\u02f2\3\2\2\2\u02f8\u02f4\3\2\2\2\u02f8\u02f9")
        buf.write("\3\2\2\2\u02f9\63\3\2\2\2\u02fa\u0305\7y\2\2\u02fb\u0306")
        buf.write("\5\u0090I\2\u02fc\u02fd\5\u0086D\2\u02fd\u02fe\7\4\2\2")
        buf.write("\u02fe\u0300\3\2\2\2\u02ff\u02fc\3\2\2\2\u02ff\u0300\3")
        buf.write("\2\2\2\u0300\u0303\3\2\2\2\u0301\u0304\5\u0088E\2\u0302")
        buf.write("\u0304\5\u0094K\2\u0303\u0301\3\2\2\2\u0303\u0302\3\2")
        buf.write("\2\2\u0304\u0306\3\2\2\2\u0305\u02fb\3\2\2\2\u0305\u02ff")
        buf.write("\3\2\2\2\u0305\u0306\3\2\2\2\u0306\65\3\2\2\2\u0307\u0309")
        buf.write("\7z\2\2\u0308\u030a\7\u0081\2\2\u0309\u0308\3\2\2\2\u0309")
        buf.write("\u030a\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u030c\5\u009e")
        buf.write("P\2\u030c\67\3\2\2\2\u030d\u0312\7\177\2\2\u030e\u0310")
        buf.write("\7\u0089\2\2\u030f\u0311\5\u00a2R\2\u0310\u030f\3\2\2")
        buf.write("\2\u0310\u0311\3\2\2\2\u0311\u0313\3\2\2\2\u0312\u030e")
        buf.write("\3\2\2\2\u0312\u0313\3\2\2\2\u0313\u0319\3\2\2\2\u0314")
        buf.write("\u0316\7\u0088\2\2\u0315\u0317\7\u0081\2\2\u0316\u0315")
        buf.write("\3\2\2\2\u0316\u0317\3\2\2\2\u0317\u0318\3\2\2\2\u0318")
        buf.write("\u031a\5\u009eP\2\u0319\u0314\3\2\2\2\u0319\u031a\3\2")
        buf.write("\2\2\u031a9\3\2\2\2\u031b\u031c\7\u0081\2\2\u031c\u031d")
        buf.write("\5\u009eP\2\u031d;\3\2\2\2\u031e\u0320\7\u0095\2\2\u031f")
        buf.write("\u0321\7v\2\2\u0320\u031f\3\2\2\2\u0320\u0321\3\2\2\2")
        buf.write("\u0321\u0322\3\2\2\2\u0322\u0327\5b\62\2\u0323\u0324\7")
        buf.write("\7\2\2\u0324\u0326\5b\62\2\u0325\u0323\3\2\2\2\u0326\u0329")
        buf.write("\3\2\2\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328")
        buf.write("\u032b\3\2\2\2\u0329\u0327\3\2\2\2\u032a\u031e\3\2\2\2")
        buf.write("\u032a\u032b\3\2\2\2\u032b\u032c\3\2\2\2\u032c\u0337\5")
        buf.write("n8\2\u032d\u032e\7o\2\2\u032e\u032f\7*\2\2\u032f\u0334")
        buf.write("\5^\60\2\u0330\u0331\7\7\2\2\u0331\u0333\5^\60\2\u0332")
        buf.write("\u0330\3\2\2\2\u0333\u0336\3\2\2\2\u0334\u0332\3\2\2\2")
        buf.write("\u0334\u0335\3\2\2\2\u0335\u0338\3\2\2\2\u0336\u0334\3")
        buf.write("\2\2\2\u0337\u032d\3\2\2\2\u0337\u0338\3\2\2\2\u0338\u033f")
        buf.write("\3\2\2\2\u0339\u033a\7d\2\2\u033a\u033d\5P)\2\u033b\u033c")
        buf.write("\t\4\2\2\u033c\u033e\5P)\2\u033d\u033b\3\2\2\2\u033d\u033e")
        buf.write("\3\2\2\2\u033e\u0340\3\2\2\2\u033f\u0339\3\2\2\2\u033f")
        buf.write("\u0340\3\2\2\2\u0340=\3\2\2\2\u0341\u0343\7\u0095\2\2")
        buf.write("\u0342\u0344\7v\2\2\u0343\u0342\3\2\2\2\u0343\u0344\3")
        buf.write("\2\2\2\u0344\u0345\3\2\2\2\u0345\u034a\5b\62\2\u0346\u0347")
        buf.write("\7\7\2\2\u0347\u0349\5b\62\2\u0348\u0346\3\2\2\2\u0349")
        buf.write("\u034c\3\2\2\2\u034a\u0348\3\2\2\2\u034a\u034b\3\2\2\2")
        buf.write("\u034b\u034e\3\2\2\2\u034c\u034a\3\2\2\2\u034d\u0341\3")
        buf.write("\2\2\2\u034d\u034e\3\2\2\2\u034e\u034f\3\2\2\2\u034f\u0355")
        buf.write("\5@!\2\u0350\u0351\5p9\2\u0351\u0352\5@!\2\u0352\u0354")
        buf.write("\3\2\2\2\u0353\u0350\3\2\2\2\u0354\u0357\3\2\2\2\u0355")
        buf.write("\u0353\3\2\2\2\u0355\u0356\3\2\2\2\u0356\u0362\3\2\2\2")
        buf.write("\u0357\u0355\3\2\2\2\u0358\u0359\7o\2\2\u0359\u035a\7")
        buf.write("*\2\2\u035a\u035f\5^\60\2\u035b\u035c\7\7\2\2\u035c\u035e")
        buf.write("\5^\60\2\u035d\u035b\3\2\2\2\u035e\u0361\3\2\2\2\u035f")
        buf.write("\u035d\3\2\2\2\u035f\u0360\3\2\2\2\u0360\u0363\3\2\2\2")
        buf.write("\u0361\u035f\3\2\2\2\u0362\u0358\3\2\2\2\u0362\u0363\3")
        buf.write("\2\2\2\u0363\u036a\3\2\2\2\u0364\u0365\7d\2\2\u0365\u0368")
        buf.write("\5P)\2\u0366\u0367\t\4\2\2\u0367\u0369\5P)\2\u0368\u0366")
        buf.write("\3\2\2\2\u0368\u0369\3\2\2\2\u0369\u036b\3\2\2\2\u036a")
        buf.write("\u0364\3\2\2\2\u036a\u036b\3\2\2\2\u036b?\3\2\2\2\u036c")
        buf.write("\u036e\7\u0082\2\2\u036d\u036f\t\6\2\2\u036e\u036d\3\2")
        buf.write("\2\2\u036e\u036f\3\2\2\2\u036f\u0370\3\2\2\2\u0370\u0375")
        buf.write("\5d\63\2\u0371\u0372\7\7\2\2\u0372\u0374\5d\63\2\u0373")
        buf.write("\u0371\3\2\2\2\u0374\u0377\3\2\2\2\u0375\u0373\3\2\2\2")
        buf.write("\u0375\u0376\3\2\2\2\u0376\u0384\3\2\2\2\u0377\u0375\3")
        buf.write("\2\2\2\u0378\u0382\7M\2\2\u0379\u037e\5f\64\2\u037a\u037b")
        buf.write("\7\7\2\2\u037b\u037d\5f\64\2\u037c\u037a\3\2\2\2\u037d")
        buf.write("\u0380\3\2\2\2\u037e\u037c\3\2\2\2\u037e\u037f\3\2\2\2")
        buf.write("\u037f\u0383\3\2\2\2\u0380\u037e\3\2\2\2\u0381\u0383\5")
        buf.write("h\65\2\u0382\u0379\3\2\2\2\u0382\u0381\3\2\2\2\u0383\u0385")
        buf.write("\3\2\2\2\u0384\u0378\3\2\2\2\u0384\u0385\3\2\2\2\u0385")
        buf.write("\u0388\3\2\2\2\u0386\u0387\7\u0094\2\2\u0387\u0389\5P")
        buf.write(")\2\u0388\u0386\3\2\2\2\u0388\u0389\3\2\2\2\u0389\u0398")
        buf.write("\3\2\2\2\u038a\u038b\7P\2\2\u038b\u038c\7*\2\2\u038c\u0391")
        buf.write("\5P)\2\u038d\u038e\7\7\2\2\u038e\u0390\5P)\2\u038f\u038d")
        buf.write("\3\2\2\2\u0390\u0393\3\2\2\2\u0391\u038f\3\2\2\2\u0391")
        buf.write("\u0392\3\2\2\2\u0392\u0396\3\2\2\2\u0393\u0391\3\2\2\2")
        buf.write("\u0394\u0395\7Q\2\2\u0395\u0397\5P)\2\u0396\u0394\3\2")
        buf.write("\2\2\u0396\u0397\3\2\2\2\u0397\u0399\3\2\2\2\u0398\u038a")
        buf.write("\3\2\2\2\u0398\u0399\3\2\2\2\u0399\u03b7\3\2\2\2\u039a")
        buf.write("\u039b\7\u0090\2\2\u039b\u039c\7\5\2\2\u039c\u03a1\5P")
        buf.write(")\2\u039d\u039e\7\7\2\2\u039e\u03a0\5P)\2\u039f\u039d")
        buf.write("\3\2\2\2\u03a0\u03a3\3\2\2\2\u03a1\u039f\3\2\2\2\u03a1")
        buf.write("\u03a2\3\2\2\2\u03a2\u03a4\3\2\2\2\u03a3\u03a1\3\2\2\2")
        buf.write("\u03a4\u03b3\7\6\2\2\u03a5\u03a6\7\7\2\2\u03a6\u03a7\7")
        buf.write("\5\2\2\u03a7\u03ac\5P)\2\u03a8\u03a9\7\7\2\2\u03a9\u03ab")
        buf.write("\5P)\2\u03aa\u03a8\3\2\2\2\u03ab\u03ae\3\2\2\2\u03ac\u03aa")
        buf.write("\3\2\2\2\u03ac\u03ad\3\2\2\2\u03ad\u03af\3\2\2\2\u03ae")
        buf.write("\u03ac\3\2\2\2\u03af\u03b0\7\6\2\2\u03b0\u03b2\3\2\2\2")
        buf.write("\u03b1\u03a5\3\2\2\2\u03b2\u03b5\3\2\2\2\u03b3\u03b1\3")
        buf.write("\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u03b7\3\2\2\2\u03b5\u03b3")
        buf.write("\3\2\2\2\u03b6\u036c\3\2\2\2\u03b6\u039a\3\2\2\2\u03b7")
        buf.write("A\3\2\2\2\u03b8\u03ba\5Z.\2\u03b9\u03b8\3\2\2\2\u03b9")
        buf.write("\u03ba\3\2\2\2\u03ba\u03bb\3\2\2\2\u03bb\u03c6\7\u008d")
        buf.write("\2\2\u03bc\u03bd\7n\2\2\u03bd\u03c7\7\177\2\2\u03be\u03bf")
        buf.write("\7n\2\2\u03bf\u03c7\7\33\2\2\u03c0\u03c1\7n\2\2\u03c1")
        buf.write("\u03c7\7|\2\2\u03c2\u03c3\7n\2\2\u03c3\u03c7\7J\2\2\u03c4")
        buf.write("\u03c5\7n\2\2\u03c5\u03c7\7S\2\2\u03c6\u03bc\3\2\2\2\u03c6")
        buf.write("\u03be\3\2\2\2\u03c6\u03c0\3\2\2\2\u03c6\u03c2\3\2\2\2")
        buf.write("\u03c6\u03c4\3\2\2\2\u03c6\u03c7\3\2\2\2\u03c7\u03c8\3")
        buf.write("\2\2\2\u03c8\u03c9\5\\/\2\u03c9\u03ca\7\u0083\2\2\u03ca")
        buf.write("\u03cb\5\u008eH\2\u03cb\u03cc\7\b\2\2\u03cc\u03d4\5P)")
        buf.write("\2\u03cd\u03ce\7\7\2\2\u03ce\u03cf\5\u008eH\2\u03cf\u03d0")
        buf.write("\7\b\2\2\u03d0\u03d1\5P)\2\u03d1\u03d3\3\2\2\2\u03d2\u03cd")
        buf.write("\3\2\2\2\u03d3\u03d6\3\2\2\2\u03d4\u03d2\3\2\2\2\u03d4")
        buf.write("\u03d5\3\2\2\2\u03d5\u03d9\3\2\2\2\u03d6\u03d4\3\2\2\2")
        buf.write("\u03d7\u03d8\7\u0094\2\2\u03d8\u03da\5P)\2\u03d9\u03d7")
        buf.write("\3\2\2\2\u03d9\u03da\3\2\2\2\u03daC\3\2\2\2\u03db\u03dd")
        buf.write("\5Z.\2\u03dc\u03db\3\2\2\2\u03dc\u03dd\3\2\2\2\u03dd\u03de")
        buf.write("\3\2\2\2\u03de\u03e9\7\u008d\2\2\u03df\u03e0\7n\2\2\u03e0")
        buf.write("\u03ea\7\177\2\2\u03e1\u03e2\7n\2\2\u03e2\u03ea\7\33\2")
        buf.write("\2\u03e3\u03e4\7n\2\2\u03e4\u03ea\7|\2\2\u03e5\u03e6\7")
        buf.write("n\2\2\u03e6\u03ea\7J\2\2\u03e7\u03e8\7n\2\2\u03e8\u03ea")
        buf.write("\7S\2\2\u03e9\u03df\3\2\2\2\u03e9\u03e1\3\2\2\2\u03e9")
        buf.write("\u03e3\3\2\2\2\u03e9\u03e5\3\2\2\2\u03e9\u03e7\3\2\2\2")
        buf.write("\u03e9\u03ea\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec\5")
        buf.write("\\/\2\u03ec\u03ed\7\u0083\2\2\u03ed\u03ee\5\u008eH\2\u03ee")
        buf.write("\u03ef\7\b\2\2\u03ef\u03f7\5P)\2\u03f0\u03f1\7\7\2\2\u03f1")
        buf.write("\u03f2\5\u008eH\2\u03f2\u03f3\7\b\2\2\u03f3\u03f4\5P)")
        buf.write("\2\u03f4\u03f6\3\2\2\2\u03f5\u03f0\3\2\2\2\u03f6\u03f9")
        buf.write("\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8")
        buf.write("\u03fc\3\2\2\2\u03f9\u03f7\3\2\2\2\u03fa\u03fb\7\u0094")
        buf.write("\2\2\u03fb\u03fd\5P)\2\u03fc\u03fa\3\2\2\2\u03fc\u03fd")
        buf.write("\3\2\2\2\u03fd\u0410\3\2\2\2\u03fe\u03ff\7o\2\2\u03ff")
        buf.write("\u0400\7*\2\2\u0400\u0405\5^\60\2\u0401\u0402\7\7\2\2")
        buf.write("\u0402\u0404\5^\60\2\u0403\u0401\3\2\2\2\u0404\u0407\3")
        buf.write("\2\2\2\u0405\u0403\3\2\2\2\u0405\u0406\3\2\2\2\u0406\u0409")
        buf.write("\3\2\2\2\u0407\u0405\3\2\2\2\u0408\u03fe\3\2\2\2\u0408")
        buf.write("\u0409\3\2\2\2\u0409\u040a\3\2\2\2\u040a\u040b\7d\2\2")
        buf.write("\u040b\u040e\5P)\2\u040c\u040d\t\4\2\2\u040d\u040f\5P")
        buf.write(")\2\u040e\u040c\3\2\2\2\u040e\u040f\3\2\2\2\u040f\u0411")
        buf.write("\3\2\2\2\u0410\u0408\3\2\2\2\u0410\u0411\3\2\2\2\u0411")
        buf.write("E\3\2\2\2\u0412\u0413\7\u008f\2\2\u0413G\3\2\2\2\u0414")
        buf.write("\u0416\5\u008eH\2\u0415\u0417\5J&\2\u0416\u0415\3\2\2")
        buf.write("\2\u0416\u0417\3\2\2\2\u0417\u041b\3\2\2\2\u0418\u041a")
        buf.write("\5L\'\2\u0419\u0418\3\2\2\2\u041a\u041d\3\2\2\2\u041b")
        buf.write("\u0419\3\2\2\2\u041b\u041c\3\2\2\2\u041cI\3\2\2\2\u041d")
        buf.write("\u041b\3\2\2\2\u041e\u0420\5\u0082B\2\u041f\u041e\3\2")
        buf.write("\2\2\u0420\u0421\3\2\2\2\u0421\u041f\3\2\2\2\u0421\u0422")
        buf.write("\3\2\2\2\u0422\u042d\3\2\2\2\u0423\u0424\7\5\2\2\u0424")
        buf.write("\u0425\5t;\2\u0425\u0426\7\6\2\2\u0426\u042e\3\2\2\2\u0427")
        buf.write("\u0428\7\5\2\2\u0428\u0429\5t;\2\u0429\u042a\7\7\2\2\u042a")
        buf.write("\u042b\5t;\2\u042b\u042c\7\6\2\2\u042c\u042e\3\2\2\2\u042d")
        buf.write("\u0423\3\2\2\2\u042d\u0427\3\2\2\2\u042d\u042e\3\2\2\2")
        buf.write("\u042eK\3\2\2\2\u042f\u0430\7\63\2\2\u0430\u0432\5\u0082")
        buf.write("B\2\u0431\u042f\3\2\2\2\u0431\u0432\3\2\2\2\u0432\u0454")
        buf.write("\3\2\2\2\u0433\u0434\7s\2\2\u0434\u0436\7a\2\2\u0435\u0437")
        buf.write("\t\7\2\2\u0436\u0435\3\2\2\2\u0436\u0437\3\2\2\2\u0437")
        buf.write("\u0438\3\2\2\2\u0438\u043a\5N(\2\u0439\u043b\7&\2\2\u043a")
        buf.write("\u0439\3\2\2\2\u043a\u043b\3\2\2\2\u043b\u0455\3\2\2\2")
        buf.write("\u043c\u043e\7h\2\2\u043d\u043c\3\2\2\2\u043d\u043e\3")
        buf.write("\2\2\2\u043e\u043f\3\2\2\2\u043f\u0440\7j\2\2\u0440\u0455")
        buf.write("\5N(\2\u0441\u0442\7\u008c\2\2\u0442\u0455\5N(\2\u0443")
        buf.write("\u0444\7.\2\2\u0444\u0445\7\5\2\2\u0445\u0446\5P)\2\u0446")
        buf.write("\u0447\7\6\2\2\u0447\u0455\3\2\2\2\u0448\u044f\7:\2\2")
        buf.write("\u0449\u0450\5t;\2\u044a\u0450\5v<\2\u044b\u044c\7\5\2")
        buf.write("\2\u044c\u044d\5P)\2\u044d\u044e\7\6\2\2\u044e\u0450\3")
        buf.write("\2\2\2\u044f\u0449\3\2\2\2\u044f\u044a\3\2\2\2\u044f\u044b")
        buf.write("\3\2\2\2\u0450\u0455\3\2\2\2\u0451\u0452\7/\2\2\u0452")
        buf.write("\u0455\5\u0090I\2\u0453\u0455\5R*\2\u0454\u0433\3\2\2")
        buf.write("\2\u0454\u043d\3\2\2\2\u0454\u0441\3\2\2\2\u0454\u0443")
        buf.write("\3\2\2\2\u0454\u0448\3\2\2\2\u0454\u0451\3\2\2\2\u0454")
        buf.write("\u0453\3\2\2\2\u0455M\3\2\2\2\u0456\u0457\7m\2\2\u0457")
        buf.write("\u0458\7\62\2\2\u0458\u045a\t\b\2\2\u0459\u0456\3\2\2")
        buf.write("\2\u0459\u045a\3\2\2\2\u045aO\3\2\2\2\u045b\u045c\b)\1")
        buf.write("\2\u045c\u04a8\5v<\2\u045d\u04a8\7\u0099\2\2\u045e\u045f")
        buf.write("\5\u0086D\2\u045f\u0460\7\4\2\2\u0460\u0462\3\2\2\2\u0461")
        buf.write("\u045e\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0463\3\2\2\2")
        buf.write("\u0463\u0464\5\u0088E\2\u0464\u0465\7\4\2\2\u0465\u0467")
        buf.write("\3\2\2\2\u0466\u0461\3\2\2\2\u0466\u0467\3\2\2\2\u0467")
        buf.write("\u0468\3\2\2\2\u0468\u04a8\5\u008eH\2\u0469\u046a\5x=")
        buf.write("\2\u046a\u046b\5P)\27\u046b\u04a8\3\2\2\2\u046c\u046d")
        buf.write("\5\u0084C\2\u046d\u047a\7\5\2\2\u046e\u0470\7@\2\2\u046f")
        buf.write("\u046e\3\2\2\2\u046f\u0470\3\2\2\2\u0470\u0471\3\2\2\2")
        buf.write("\u0471\u0476\5P)\2\u0472\u0473\7\7\2\2\u0473\u0475\5P")
        buf.write(")\2\u0474\u0472\3\2\2\2\u0475\u0478\3\2\2\2\u0476\u0474")
        buf.write("\3\2\2\2\u0476\u0477\3\2\2\2\u0477\u047b\3\2\2\2\u0478")
        buf.write("\u0476\3\2\2\2\u0479\u047b\7\t\2\2\u047a\u046f\3\2\2\2")
        buf.write("\u047a\u0479\3\2\2\2\u047a\u047b\3\2\2\2\u047b\u047c\3")
        buf.write("\2\2\2\u047c\u047d\7\6\2\2\u047d\u04a8\3\2\2\2\u047e\u047f")
        buf.write("\7\5\2\2\u047f\u0480\5P)\2\u0480\u0481\7\6\2\2\u0481\u04a8")
        buf.write("\3\2\2\2\u0482\u0483\7-\2\2\u0483\u0484\7\5\2\2\u0484")
        buf.write("\u0485\5P)\2\u0485\u0486\7#\2\2\u0486\u0487\5J&\2\u0487")
        buf.write("\u0488\7\6\2\2\u0488\u04a8\3\2\2\2\u0489\u048b\7h\2\2")
        buf.write("\u048a\u0489\3\2\2\2\u048a\u048b\3\2\2\2\u048b\u048c\3")
        buf.write("\2\2\2\u048c\u048e\7H\2\2\u048d\u048a\3\2\2\2\u048d\u048e")
        buf.write("\3\2\2\2\u048e\u048f\3\2\2\2\u048f\u0490\7\5\2\2\u0490")
        buf.write("\u0491\5> \2\u0491\u0492\7\6\2\2\u0492\u04a8\3\2\2\2\u0493")
        buf.write("\u0495\7,\2\2\u0494\u0496\5P)\2\u0495\u0494\3\2\2\2\u0495")
        buf.write("\u0496\3\2\2\2\u0496\u049c\3\2\2\2\u0497\u0498\7\u0093")
        buf.write("\2\2\u0498\u0499\5P)\2\u0499\u049a\7\u0087\2\2\u049a\u049b")
        buf.write("\5P)\2\u049b\u049d\3\2\2\2\u049c\u0497\3\2\2\2\u049d\u049e")
        buf.write("\3\2\2\2\u049e\u049c\3\2\2\2\u049e\u049f\3\2\2\2\u049f")
        buf.write("\u04a2\3\2\2\2\u04a0\u04a1\7C\2\2\u04a1\u04a3\5P)\2\u04a2")
        buf.write("\u04a0\3\2\2\2\u04a2\u04a3\3\2\2\2\u04a3\u04a4\3\2\2\2")
        buf.write("\u04a4\u04a5\7D\2\2\u04a5\u04a8\3\2\2\2\u04a6\u04a8\5")
        buf.write("T+\2\u04a7\u045b\3\2\2\2\u04a7\u045d\3\2\2\2\u04a7\u0466")
        buf.write("\3\2\2\2\u04a7\u0469\3\2\2\2\u04a7\u046c\3\2\2\2\u04a7")
        buf.write("\u047e\3\2\2\2\u04a7\u0482\3\2\2\2\u04a7\u048d\3\2\2\2")
        buf.write("\u04a7\u0493\3\2\2\2\u04a7\u04a6\3\2\2\2\u04a8\u050d\3")
        buf.write("\2\2\2\u04a9\u04aa\f\26\2\2\u04aa\u04ab\7\r\2\2\u04ab")
        buf.write("\u050c\5P)\27\u04ac\u04ad\f\25\2\2\u04ad\u04ae\t\t\2\2")
        buf.write("\u04ae\u050c\5P)\26\u04af\u04b0\f\24\2\2\u04b0\u04b1\t")
        buf.write("\n\2\2\u04b1\u050c\5P)\25\u04b2\u04b3\f\23\2\2\u04b3\u04b4")
        buf.write("\t\13\2\2\u04b4\u050c\5P)\24\u04b5\u04b6\f\22\2\2\u04b6")
        buf.write("\u04b7\t\f\2\2\u04b7\u050c\5P)\23\u04b8\u04c5\f\21\2\2")
        buf.write("\u04b9\u04c6\7\b\2\2\u04ba\u04c6\7\30\2\2\u04bb\u04c6")
        buf.write("\7\31\2\2\u04bc\u04c6\7\32\2\2\u04bd\u04c6\7^\2\2\u04be")
        buf.write("\u04bf\7^\2\2\u04bf\u04c6\7h\2\2\u04c0\u04c6\7U\2\2\u04c1")
        buf.write("\u04c6\7c\2\2\u04c2\u04c6\7O\2\2\u04c3\u04c6\7e\2\2\u04c4")
        buf.write("\u04c6\7x\2\2\u04c5\u04b9\3\2\2\2\u04c5\u04ba\3\2\2\2")
        buf.write("\u04c5\u04bb\3\2\2\2\u04c5\u04bc\3\2\2\2\u04c5\u04bd\3")
        buf.write("\2\2\2\u04c5\u04be\3\2\2\2\u04c5\u04c0\3\2\2\2\u04c5\u04c1")
        buf.write("\3\2\2\2\u04c5\u04c2\3\2\2\2\u04c5\u04c3\3\2\2\2\u04c5")
        buf.write("\u04c4\3\2\2\2\u04c6\u04c7\3\2\2\2\u04c7\u050c\5P)\22")
        buf.write("\u04c8\u04c9\f\20\2\2\u04c9\u04ca\7\"\2\2\u04ca\u050c")
        buf.write("\5P)\21\u04cb\u04cc\f\17\2\2\u04cc\u04cd\7n\2\2\u04cd")
        buf.write("\u050c\5P)\20\u04ce\u04cf\f\b\2\2\u04cf\u04d1\7^\2\2\u04d0")
        buf.write("\u04d2\7h\2\2\u04d1\u04d0\3\2\2\2\u04d1\u04d2\3\2\2\2")
        buf.write("\u04d2\u04d3\3\2\2\2\u04d3\u050c\5P)\t\u04d4\u04d6\f\7")
        buf.write("\2\2\u04d5\u04d7\7h\2\2\u04d6\u04d5\3\2\2\2\u04d6\u04d7")
        buf.write("\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04d9\7)\2\2\u04d9")
        buf.write("\u04da\5P)\2\u04da\u04db\7\"\2\2\u04db\u04dc\5P)\b\u04dc")
        buf.write("\u050c\3\2\2\2\u04dd\u04de\f\13\2\2\u04de\u04df\7/\2\2")
        buf.write("\u04df\u050c\5\u0090I\2\u04e0\u04e2\f\n\2\2\u04e1\u04e3")
        buf.write("\7h\2\2\u04e2\u04e1\3\2\2\2\u04e2\u04e3\3\2\2\2\u04e3")
        buf.write("\u04e4\3\2\2\2\u04e4\u04e5\t\r\2\2\u04e5\u04e8\5P)\2\u04e6")
        buf.write("\u04e7\7E\2\2\u04e7\u04e9\5P)\2\u04e8\u04e6\3\2\2\2\u04e8")
        buf.write("\u04e9\3\2\2\2\u04e9\u050c\3\2\2\2\u04ea\u04ef\f\t\2\2")
        buf.write("\u04eb\u04f0\7_\2\2\u04ec\u04f0\7i\2\2\u04ed\u04ee\7h")
        buf.write("\2\2\u04ee\u04f0\7j\2\2\u04ef\u04eb\3\2\2\2\u04ef\u04ec")
        buf.write("\3\2\2\2\u04ef\u04ed\3\2\2\2\u04f0\u050c\3\2\2\2\u04f1")
        buf.write("\u04f3\f\6\2\2\u04f2\u04f4\7h\2\2\u04f3\u04f2\3\2\2\2")
        buf.write("\u04f3\u04f4\3\2\2\2\u04f4\u04f5\3\2\2\2\u04f5\u0509\7")
        buf.write("U\2\2\u04f6\u0500\7\5\2\2\u04f7\u0501\5> \2\u04f8\u04fd")
        buf.write("\5P)\2\u04f9\u04fa\7\7\2\2\u04fa\u04fc\5P)\2\u04fb\u04f9")
        buf.write("\3\2\2\2\u04fc\u04ff\3\2\2\2\u04fd\u04fb\3\2\2\2\u04fd")
        buf.write("\u04fe\3\2\2\2\u04fe\u0501\3\2\2\2\u04ff\u04fd\3\2\2\2")
        buf.write("\u0500\u04f7\3\2\2\2\u0500\u04f8\3\2\2\2\u0500\u0501\3")
        buf.write("\2\2\2\u0501\u0502\3\2\2\2\u0502\u050a\7\6\2\2\u0503\u0504")
        buf.write("\5\u0086D\2\u0504\u0505\7\4\2\2\u0505\u0507\3\2\2\2\u0506")
        buf.write("\u0503\3\2\2\2\u0506\u0507\3\2\2\2\u0507\u0508\3\2\2\2")
        buf.write("\u0508\u050a\5\u0088E\2\u0509\u04f6\3\2\2\2\u0509\u0506")
        buf.write("\3\2\2\2\u050a\u050c\3\2\2\2\u050b\u04a9\3\2\2\2\u050b")
        buf.write("\u04ac\3\2\2\2\u050b\u04af\3\2\2\2\u050b\u04b2\3\2\2\2")
        buf.write("\u050b\u04b5\3\2\2\2\u050b\u04b8\3\2\2\2\u050b\u04c8\3")
        buf.write("\2\2\2\u050b\u04cb\3\2\2\2\u050b\u04ce\3\2\2\2\u050b\u04d4")
        buf.write("\3\2\2\2\u050b\u04dd\3\2\2\2\u050b\u04e0\3\2\2\2\u050b")
        buf.write("\u04ea\3\2\2\2\u050b\u04f1\3\2\2\2\u050c\u050f\3\2\2\2")
        buf.write("\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050eQ\3\2\2")
        buf.write("\2\u050f\u050d\3\2\2\2\u0510\u0511\7w\2\2\u0511\u051d")
        buf.write("\5\u0092J\2\u0512\u0513\7\5\2\2\u0513\u0518\5\u008eH\2")
        buf.write("\u0514\u0515\7\7\2\2\u0515\u0517\5\u008eH\2\u0516\u0514")
        buf.write("\3\2\2\2\u0517\u051a\3\2\2\2\u0518\u0516\3\2\2\2\u0518")
        buf.write("\u0519\3\2\2\2\u0519\u051b\3\2\2\2\u051a\u0518\3\2\2\2")
        buf.write("\u051b\u051c\7\6\2\2\u051c\u051e\3\2\2\2\u051d\u0512\3")
        buf.write("\2\2\2\u051d\u051e\3\2\2\2\u051e\u0531\3\2\2\2\u051f\u0520")
        buf.write("\7m\2\2\u0520\u0529\t\16\2\2\u0521\u0522\7\u0083\2\2\u0522")
        buf.write("\u052a\7j\2\2\u0523\u0524\7\u0083\2\2\u0524\u052a\7:\2")
        buf.write("\2\u0525\u052a\7+\2\2\u0526\u052a\7}\2\2\u0527\u0528\7")
        buf.write("g\2\2\u0528\u052a\7\34\2\2\u0529\u0521\3\2\2\2\u0529\u0523")
        buf.write("\3\2\2\2\u0529\u0525\3\2\2\2\u0529\u0526\3\2\2\2\u0529")
        buf.write("\u0527\3\2\2\2\u052a\u052e\3\2\2\2\u052b\u052c\7e\2\2")
        buf.write("\u052c\u052e\5\u0082B\2\u052d\u051f\3\2\2\2\u052d\u052b")
        buf.write("\3\2\2\2\u052e\u0530\3\2\2\2\u052f\u052d\3\2\2\2\u0530")
        buf.write("\u0533\3\2\2\2\u0531\u052f\3\2\2\2\u0531\u0532\3\2\2\2")
        buf.write("\u0532\u053e\3\2\2\2\u0533\u0531\3\2\2\2\u0534\u0536\7")
        buf.write("h\2\2\u0535\u0534\3\2\2\2\u0535\u0536\3\2\2\2\u0536\u0537")
        buf.write("\3\2\2\2\u0537\u053c\7;\2\2\u0538\u0539\7X\2\2\u0539\u053d")
        buf.write("\7<\2\2\u053a\u053b\7X\2\2\u053b\u053d\7T\2\2\u053c\u0538")
        buf.write("\3\2\2\2\u053c\u053a\3\2\2\2\u053c\u053d\3\2\2\2\u053d")
        buf.write("\u053f\3\2\2\2\u053e\u0535\3\2\2\2\u053e\u053f\3\2\2\2")
        buf.write("\u053fS\3\2\2\2\u0540\u0541\7u\2\2\u0541\u0546\7\5\2\2")
        buf.write("\u0542\u0547\7S\2\2\u0543\u0544\t\17\2\2\u0544\u0545\7")
        buf.write("\7\2\2\u0545\u0547\5z>\2\u0546\u0542\3\2\2\2\u0546\u0543")
        buf.write("\3\2\2\2\u0547\u0548\3\2\2\2\u0548\u0549\7\6\2\2\u0549")
        buf.write("U\3\2\2\2\u054a\u054d\5\u008eH\2\u054b\u054c\7/\2\2\u054c")
        buf.write("\u054e\5\u0090I\2\u054d\u054b\3\2\2\2\u054d\u054e\3\2")
        buf.write("\2\2\u054e\u0550\3\2\2\2\u054f\u0551\t\7\2\2\u0550\u054f")
        buf.write("\3\2\2\2\u0550\u0551\3\2\2\2\u0551W\3\2\2\2\u0552\u0553")
        buf.write("\7\63\2\2\u0553\u0555\5\u0082B\2\u0554\u0552\3\2\2\2\u0554")
        buf.write("\u0555\3\2\2\2\u0555\u057a\3\2\2\2\u0556\u0557\7s\2\2")
        buf.write("\u0557\u055a\7a\2\2\u0558\u055a\7\u008c\2\2\u0559\u0556")
        buf.write("\3\2\2\2\u0559\u0558\3\2\2\2\u055a\u055b\3\2\2\2\u055b")
        buf.write("\u055c\7\5\2\2\u055c\u0561\5V,\2\u055d\u055e\7\7\2\2\u055e")
        buf.write("\u0560\5V,\2\u055f\u055d\3\2\2\2\u0560\u0563\3\2\2\2\u0561")
        buf.write("\u055f\3\2\2\2\u0561\u0562\3\2\2\2\u0562\u0564\3\2\2\2")
        buf.write("\u0563\u0561\3\2\2\2\u0564\u0565\7\6\2\2\u0565\u0566\5")
        buf.write("N(\2\u0566\u057b\3\2\2\2\u0567\u0568\7.\2\2\u0568\u0569")
        buf.write("\7\5\2\2\u0569\u056a\5P)\2\u056a\u056b\7\6\2\2\u056b\u057b")
        buf.write("\3\2\2\2\u056c\u056d\7L\2\2\u056d\u056e\7a\2\2\u056e\u056f")
        buf.write("\7\5\2\2\u056f\u0574\5\u008eH\2\u0570\u0571\7\7\2\2\u0571")
        buf.write("\u0573\5\u008eH\2\u0572\u0570\3\2\2\2\u0573\u0576\3\2")
        buf.write("\2\2\u0574\u0572\3\2\2\2\u0574\u0575\3\2\2\2\u0575\u0577")
        buf.write("\3\2\2\2\u0576\u0574\3\2\2\2\u0577\u0578\7\6\2\2\u0578")
        buf.write("\u0579\5R*\2\u0579\u057b\3\2\2\2\u057a\u0559\3\2\2\2\u057a")
        buf.write("\u0567\3\2\2\2\u057a\u056c\3\2\2\2\u057bY\3\2\2\2\u057c")
        buf.write("\u057e\7\u0095\2\2\u057d\u057f\7v\2\2\u057e\u057d\3\2")
        buf.write("\2\2\u057e\u057f\3\2\2\2\u057f\u0580\3\2\2\2\u0580\u0581")
        buf.write("\5r:\2\u0581\u0582\7#\2\2\u0582\u0583\7\5\2\2\u0583\u0584")
        buf.write("\5> \2\u0584\u058e\7\6\2\2\u0585\u0586\7\7\2\2\u0586\u0587")
        buf.write("\5r:\2\u0587\u0588\7#\2\2\u0588\u0589\7\5\2\2\u0589\u058a")
        buf.write("\5> \2\u058a\u058b\7\6\2\2\u058b\u058d\3\2\2\2\u058c\u0585")
        buf.write("\3\2\2\2\u058d\u0590\3\2\2\2\u058e\u058c\3\2\2\2\u058e")
        buf.write("\u058f\3\2\2\2\u058f[\3\2\2\2\u0590\u058e\3\2\2\2\u0591")
        buf.write("\u0592\5\u0086D\2\u0592\u0593\7\4\2\2\u0593\u0595\3\2")
        buf.write("\2\2\u0594\u0591\3\2\2\2\u0594\u0595\3\2\2\2\u0595\u0596")
        buf.write("\3\2\2\2\u0596\u059c\5\u0088E\2\u0597\u0598\7W\2\2\u0598")
        buf.write("\u0599\7*\2\2\u0599\u059d\5\u0094K\2\u059a\u059b\7h\2")
        buf.write("\2\u059b\u059d\7W\2\2\u059c\u0597\3\2\2\2\u059c\u059a")
        buf.write("\3\2\2\2\u059c\u059d\3\2\2\2\u059d]\3\2\2\2\u059e\u05a1")
        buf.write("\5P)\2\u059f\u05a0\7/\2\2\u05a0\u05a2\5\u0090I\2\u05a1")
        buf.write("\u059f\3\2\2\2\u05a1\u05a2\3\2\2\2\u05a2\u05a4\3\2\2\2")
        buf.write("\u05a3\u05a5\t\7\2\2\u05a4\u05a3\3\2\2\2\u05a4\u05a5\3")
        buf.write("\2\2\2\u05a5_\3\2\2\2\u05a6\u05aa\5t;\2\u05a7\u05aa\5")
        buf.write("\u0082B\2\u05a8\u05aa\7\u009a\2\2\u05a9\u05a6\3\2\2\2")
        buf.write("\u05a9\u05a7\3\2\2\2\u05a9\u05a8\3\2\2\2\u05aaa\3\2\2")
        buf.write("\2\u05ab\u05b7\5\u0088E\2\u05ac\u05ad\7\5\2\2\u05ad\u05b2")
        buf.write("\5\u008eH\2\u05ae\u05af\7\7\2\2\u05af\u05b1\5\u008eH\2")
        buf.write("\u05b0\u05ae\3\2\2\2\u05b1\u05b4\3\2\2\2\u05b2\u05b0\3")
        buf.write("\2\2\2\u05b2\u05b3\3\2\2\2\u05b3\u05b5\3\2\2\2\u05b4\u05b2")
        buf.write("\3\2\2\2\u05b5\u05b6\7\6\2\2\u05b6\u05b8\3\2\2\2\u05b7")
        buf.write("\u05ac\3\2\2\2\u05b7\u05b8\3\2\2\2\u05b8\u05b9\3\2\2\2")
        buf.write("\u05b9\u05ba\7#\2\2\u05ba\u05bb\7\5\2\2\u05bb\u05bc\5")
        buf.write("> \2\u05bc\u05bd\7\6\2\2\u05bdc\3\2\2\2\u05be\u05cb\7")
        buf.write("\t\2\2\u05bf\u05c0\5\u0088E\2\u05c0\u05c1\7\4\2\2\u05c1")
        buf.write("\u05c2\7\t\2\2\u05c2\u05cb\3\2\2\2\u05c3\u05c8\5P)\2\u05c4")
        buf.write("\u05c6\7#\2\2\u05c5\u05c4\3\2\2\2\u05c5\u05c6\3\2\2\2")
        buf.write("\u05c6\u05c7\3\2\2\2\u05c7\u05c9\5~@\2\u05c8\u05c5\3\2")
        buf.write("\2\2\u05c8\u05c9\3\2\2\2\u05c9\u05cb\3\2\2\2\u05ca\u05be")
        buf.write("\3\2\2\2\u05ca\u05bf\3\2\2\2\u05ca\u05c3\3\2\2\2\u05cb")
        buf.write("e\3\2\2\2\u05cc\u05cd\5\u0086D\2\u05cd\u05ce\7\4\2\2\u05ce")
        buf.write("\u05d0\3\2\2\2\u05cf\u05cc\3\2\2\2\u05cf\u05d0\3\2\2\2")
        buf.write("\u05d0\u05d1\3\2\2\2\u05d1\u05d6\5\u0088E\2\u05d2\u05d4")
        buf.write("\7#\2\2\u05d3\u05d2\3\2\2\2\u05d3\u05d4\3\2\2\2\u05d4")
        buf.write("\u05d5\3\2\2\2\u05d5\u05d7\5\u00a0Q\2\u05d6\u05d3\3\2")
        buf.write("\2\2\u05d6\u05d7\3\2\2\2\u05d7\u05dd\3\2\2\2\u05d8\u05d9")
        buf.write("\7W\2\2\u05d9\u05da\7*\2\2\u05da\u05de\5\u0094K\2\u05db")
        buf.write("\u05dc\7h\2\2\u05dc\u05de\7W\2\2\u05dd\u05d8\3\2\2\2\u05dd")
        buf.write("\u05db\3\2\2\2\u05dd\u05de\3\2\2\2\u05de\u05fc\3\2\2\2")
        buf.write("\u05df\u05e9\7\5\2\2\u05e0\u05e5\5f\64\2\u05e1\u05e2\7")
        buf.write("\7\2\2\u05e2\u05e4\5f\64\2\u05e3\u05e1\3\2\2\2\u05e4\u05e7")
        buf.write("\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5\u05e6\3\2\2\2\u05e6")
        buf.write("\u05ea\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e8\u05ea\5h\65\2")
        buf.write("\u05e9\u05e0\3\2\2\2\u05e9\u05e8\3\2\2\2\u05ea\u05eb\3")
        buf.write("\2\2\2\u05eb\u05f0\7\6\2\2\u05ec\u05ee\7#\2\2\u05ed\u05ec")
        buf.write("\3\2\2\2\u05ed\u05ee\3\2\2\2\u05ee\u05ef\3\2\2\2\u05ef")
        buf.write("\u05f1\5\u00a0Q\2\u05f0\u05ed\3\2\2\2\u05f0\u05f1\3\2")
        buf.write("\2\2\u05f1\u05fc\3\2\2\2\u05f2\u05f3\7\5\2\2\u05f3\u05f4")
        buf.write("\5> \2\u05f4\u05f9\7\6\2\2\u05f5\u05f7\7#\2\2\u05f6\u05f5")
        buf.write("\3\2\2\2\u05f6\u05f7\3\2\2\2\u05f7\u05f8\3\2\2\2\u05f8")
        buf.write("\u05fa\5\u00a0Q\2\u05f9\u05f6\3\2\2\2\u05f9\u05fa\3\2")
        buf.write("\2\2\u05fa\u05fc\3\2\2\2\u05fb\u05cf\3\2\2\2\u05fb\u05df")
        buf.write("\3\2\2\2\u05fb\u05f2\3\2\2\2\u05fcg\3\2\2\2\u05fd\u0604")
        buf.write("\5f\64\2\u05fe\u05ff\5j\66\2\u05ff\u0600\5f\64\2\u0600")
        buf.write("\u0601\5l\67\2\u0601\u0603\3\2\2\2\u0602\u05fe\3\2\2\2")
        buf.write("\u0603\u0606\3\2\2\2\u0604\u0602\3\2\2\2\u0604\u0605\3")
        buf.write("\2\2\2\u0605i\3\2\2\2\u0606\u0604\3\2\2\2\u0607\u0615")
        buf.write("\7\7\2\2\u0608\u060a\7f\2\2\u0609\u0608\3\2\2\2\u0609")
        buf.write("\u060a\3\2\2\2\u060a\u0611\3\2\2\2\u060b\u060d\7b\2\2")
        buf.write("\u060c\u060e\7p\2\2\u060d\u060c\3\2\2\2\u060d\u060e\3")
        buf.write("\2\2\2\u060e\u0612\3\2\2\2\u060f\u0612\7Y\2\2\u0610\u0612")
        buf.write("\7\65\2\2\u0611\u060b\3\2\2\2\u0611\u060f\3\2\2\2\u0611")
        buf.write("\u0610\3\2\2\2\u0611\u0612\3\2\2\2\u0612\u0613\3\2\2\2")
        buf.write("\u0613\u0615\7`\2\2\u0614\u0607\3\2\2\2\u0614\u0609\3")
        buf.write("\2\2\2\u0615k\3\2\2\2\u0616\u0617\7m\2\2\u0617\u0625\5")
        buf.write("P)\2\u0618\u0619\7\u008e\2\2\u0619\u061a\7\5\2\2\u061a")
        buf.write("\u061f\5\u008eH\2\u061b\u061c\7\7\2\2\u061c\u061e\5\u008e")
        buf.write("H\2\u061d\u061b\3\2\2\2\u061e\u0621\3\2\2\2\u061f\u061d")
        buf.write("\3\2\2\2\u061f\u0620\3\2\2\2\u0620\u0622\3\2\2\2\u0621")
        buf.write("\u061f\3\2\2\2\u0622\u0623\7\6\2\2\u0623\u0625\3\2\2\2")
        buf.write("\u0624\u0616\3\2\2\2\u0624\u0618\3\2\2\2\u0624\u0625\3")
        buf.write("\2\2\2\u0625m\3\2\2\2\u0626\u0628\7\u0082\2\2\u0627\u0629")
        buf.write("\t\6\2\2\u0628\u0627\3\2\2\2\u0628\u0629\3\2\2\2\u0629")
        buf.write("\u062a\3\2\2\2\u062a\u062f\5d\63\2\u062b\u062c\7\7\2\2")
        buf.write("\u062c\u062e\5d\63\2\u062d\u062b\3\2\2\2\u062e\u0631\3")
        buf.write("\2\2\2\u062f\u062d\3\2\2\2\u062f\u0630\3\2\2\2\u0630\u063e")
        buf.write("\3\2\2\2\u0631\u062f\3\2\2\2\u0632\u063c\7M\2\2\u0633")
        buf.write("\u0638\5f\64\2\u0634\u0635\7\7\2\2\u0635\u0637\5f\64\2")
        buf.write("\u0636\u0634\3\2\2\2\u0637\u063a\3\2\2\2\u0638\u0636\3")
        buf.write("\2\2\2\u0638\u0639\3\2\2\2\u0639\u063d\3\2\2\2\u063a\u0638")
        buf.write("\3\2\2\2\u063b\u063d\5h\65\2\u063c\u0633\3\2\2\2\u063c")
        buf.write("\u063b\3\2\2\2\u063d\u063f\3\2\2\2\u063e\u0632\3\2\2\2")
        buf.write("\u063e\u063f\3\2\2\2\u063f\u0642\3\2\2\2\u0640\u0641\7")
        buf.write("\u0094\2\2\u0641\u0643\5P)\2\u0642\u0640\3\2\2\2\u0642")
        buf.write("\u0643\3\2\2\2\u0643\u0652\3\2\2\2\u0644\u0645\7P\2\2")
        buf.write("\u0645\u0646\7*\2\2\u0646\u064b\5P)\2\u0647\u0648\7\7")
        buf.write("\2\2\u0648\u064a\5P)\2\u0649\u0647\3\2\2\2\u064a\u064d")
        buf.write("\3\2\2\2\u064b\u0649\3\2\2\2\u064b\u064c\3\2\2\2\u064c")
        buf.write("\u0650\3\2\2\2\u064d\u064b\3\2\2\2\u064e\u064f\7Q\2\2")
        buf.write("\u064f\u0651\5P)\2\u0650\u064e\3\2\2\2\u0650\u0651\3\2")
        buf.write("\2\2\u0651\u0653\3\2\2\2\u0652\u0644\3\2\2\2\u0652\u0653")
        buf.write("\3\2\2\2\u0653\u0671\3\2\2\2\u0654\u0655\7\u0090\2\2\u0655")
        buf.write("\u0656\7\5\2\2\u0656\u065b\5P)\2\u0657\u0658\7\7\2\2\u0658")
        buf.write("\u065a\5P)\2\u0659\u0657\3\2\2\2\u065a\u065d\3\2\2\2\u065b")
        buf.write("\u0659\3\2\2\2\u065b\u065c\3\2\2\2\u065c\u065e\3\2\2\2")
        buf.write("\u065d\u065b\3\2\2\2\u065e\u066d\7\6\2\2\u065f\u0660\7")
        buf.write("\7\2\2\u0660\u0661\7\5\2\2\u0661\u0666\5P)\2\u0662\u0663")
        buf.write("\7\7\2\2\u0663\u0665\5P)\2\u0664\u0662\3\2\2\2\u0665\u0668")
        buf.write("\3\2\2\2\u0666\u0664\3\2\2\2\u0666\u0667\3\2\2\2\u0667")
        buf.write("\u0669\3\2\2\2\u0668\u0666\3\2\2\2\u0669\u066a\7\6\2\2")
        buf.write("\u066a\u066c\3\2\2\2\u066b\u065f\3\2\2\2\u066c\u066f\3")
        buf.write("\2\2\2\u066d\u066b\3\2\2\2\u066d\u066e\3\2\2\2\u066e\u0671")
        buf.write("\3\2\2\2\u066f\u066d\3\2\2\2\u0670\u0626\3\2\2\2\u0670")
        buf.write("\u0654\3\2\2\2\u0671o\3\2\2\2\u0672\u0678\7\u008b\2\2")
        buf.write("\u0673\u0674\7\u008b\2\2\u0674\u0678\7\37\2\2\u0675\u0678")
        buf.write("\7\\\2\2\u0676\u0678\7F\2\2\u0677\u0672\3\2\2\2\u0677")
        buf.write("\u0673\3\2\2\2\u0677\u0675\3\2\2\2\u0677\u0676\3\2\2\2")
        buf.write("\u0678q\3\2\2\2\u0679\u0685\5\u0088E\2\u067a\u067b\7\5")
        buf.write("\2\2\u067b\u0680\5\u008eH\2\u067c\u067d\7\7\2\2\u067d")
        buf.write("\u067f\5\u008eH\2\u067e\u067c\3\2\2\2\u067f\u0682\3\2")
        buf.write("\2\2\u0680\u067e\3\2\2\2\u0680\u0681\3\2\2\2\u0681\u0683")
        buf.write("\3\2\2\2\u0682\u0680\3\2\2\2\u0683\u0684\7\6\2\2\u0684")
        buf.write("\u0686\3\2\2\2\u0685\u067a\3\2\2\2\u0685\u0686\3\2\2\2")
        buf.write("\u0686s\3\2\2\2\u0687\u0689\t\n\2\2\u0688\u0687\3\2\2")
        buf.write("\2\u0688\u0689\3\2\2\2\u0689\u068a\3\2\2\2\u068a\u068b")
        buf.write("\7\u0098\2\2\u068bu\3\2\2\2\u068c\u068d\t\20\2\2\u068d")
        buf.write("w\3\2\2\2\u068e\u068f\t\21\2\2\u068fy\3\2\2\2\u0690\u0691")
        buf.write("\7\u009a\2\2\u0691{\3\2\2\2\u0692\u0695\5P)\2\u0693\u0695")
        buf.write("\5H%\2\u0694\u0692\3\2\2\2\u0694\u0693\3\2\2\2\u0695}")
        buf.write("\3\2\2\2\u0696\u0697\t\22\2\2\u0697\177\3\2\2\2\u0698")
        buf.write("\u0699\t\23\2\2\u0699\u0081\3\2\2\2\u069a\u069b\5\u00a4")
        buf.write("S\2\u069b\u0083\3\2\2\2\u069c\u069d\5\u00a4S\2\u069d\u0085")
        buf.write("\3\2\2\2\u069e\u069f\5\u00a4S\2\u069f\u0087\3\2\2\2\u06a0")
        buf.write("\u06a1\5\u00a4S\2\u06a1\u0089\3\2\2\2\u06a2\u06a3\5\u00a4")
        buf.write("S\2\u06a3\u008b\3\2\2\2\u06a4\u06a5\5\u00a4S\2\u06a5\u008d")
        buf.write("\3\2\2\2\u06a6\u06a7\5\u00a4S\2\u06a7\u008f\3\2\2\2\u06a8")
        buf.write("\u06a9\5\u00a4S\2\u06a9\u0091\3\2\2\2\u06aa\u06ab\5\u00a4")
        buf.write("S\2\u06ab\u0093\3\2\2\2\u06ac\u06ad\5\u00a4S\2\u06ad\u0095")
        buf.write("\3\2\2\2\u06ae\u06af\5\u00a4S\2\u06af\u0097\3\2\2\2\u06b0")
        buf.write("\u06b1\5\u00a4S\2\u06b1\u0099\3\2\2\2\u06b2\u06b3\5\u00a4")
        buf.write("S\2\u06b3\u009b\3\2\2\2\u06b4\u06b5\5\u00a4S\2\u06b5\u009d")
        buf.write("\3\2\2\2\u06b6\u06b7\5\u00a4S\2\u06b7\u009f\3\2\2\2\u06b8")
        buf.write("\u06b9\5\u00a4S\2\u06b9\u00a1\3\2\2\2\u06ba\u06bb\5\u00a4")
        buf.write("S\2\u06bb\u00a3\3\2\2\2\u06bc\u06c4\7\u0097\2\2\u06bd")
        buf.write("\u06c4\5\u0080A\2\u06be\u06c4\7\u009a\2\2\u06bf\u06c0")
        buf.write("\7\5\2\2\u06c0\u06c1\5\u00a4S\2\u06c1\u06c2\7\6\2\2\u06c2")
        buf.write("\u06c4\3\2\2\2\u06c3\u06bc\3\2\2\2\u06c3\u06bd\3\2\2\2")
        buf.write("\u06c3\u06be\3\2\2\2\u06c3\u06bf\3\2\2\2\u06c4\u00a5\3")
        buf.write("\2\2\2\u00f6\u00a8\u00aa\u00b5\u00bc\u00c1\u00c7\u00cd")
        buf.write("\u00cf\u00ef\u00f6\u00fe\u0101\u010a\u010e\u0116\u011a")
        buf.write("\u011c\u0121\u0123\u0127\u012e\u0131\u0136\u013a\u013f")
        buf.write("\u0148\u014b\u0151\u0153\u0157\u015d\u0162\u016d\u0173")
        buf.write("\u0177\u017d\u0182\u018b\u0192\u0198\u019c\u01a0\u01a6")
        buf.write("\u01ab\u01b2\u01bd\u01c0\u01c2\u01c8\u01ce\u01d2\u01d9")
        buf.write("\u01df\u01e5\u01eb\u01f0\u01fc\u0201\u020c\u0211\u0214")
        buf.write("\u021b\u021e\u0225\u022e\u0231\u0237\u0239\u023d\u0245")
        buf.write("\u024a\u0252\u0257\u025f\u0264\u026c\u0271\u0277\u027e")
        buf.write("\u0281\u0289\u0293\u0296\u029c\u029e\u02a1\u02b4\u02ba")
        buf.write("\u02c3\u02c8\u02d1\u02dc\u02e3\u02e9\u02ef\u02f8\u02ff")
        buf.write("\u0303\u0305\u0309\u0310\u0312\u0316\u0319\u0320\u0327")
        buf.write("\u032a\u0334\u0337\u033d\u033f\u0343\u034a\u034d\u0355")
        buf.write("\u035f\u0362\u0368\u036a\u036e\u0375\u037e\u0382\u0384")
        buf.write("\u0388\u0391\u0396\u0398\u03a1\u03ac\u03b3\u03b6\u03b9")
        buf.write("\u03c6\u03d4\u03d9\u03dc\u03e9\u03f7\u03fc\u0405\u0408")
        buf.write("\u040e\u0410\u0416\u041b\u0421\u042d\u0431\u0436\u043a")
        buf.write("\u043d\u044f\u0454\u0459\u0461\u0466\u046f\u0476\u047a")
        buf.write("\u048a\u048d\u0495\u049e\u04a2\u04a7\u04c5\u04d1\u04d6")
        buf.write("\u04e2\u04e8\u04ef\u04f3\u04fd\u0500\u0506\u0509\u050b")
        buf.write("\u050d\u0518\u051d\u0529\u052d\u0531\u0535\u053c\u053e")
        buf.write("\u0546\u054d\u0550\u0554\u0559\u0561\u0574\u057a\u057e")
        buf.write("\u058e\u0594\u059c\u05a1\u05a4\u05a9\u05b2\u05b7\u05c5")
        buf.write("\u05c8\u05ca\u05cf\u05d3\u05d6\u05dd\u05e5\u05e9\u05ed")
        buf.write("\u05f0\u05f6\u05f9\u05fb\u0604\u0609\u060d\u0611\u0614")
        buf.write("\u061f\u0624\u0628\u062f\u0638\u063c\u063e\u0642\u064b")
        buf.write("\u0650\u0652\u065b\u0666\u066d\u0670\u0677\u0680\u0685")
        buf.write("\u0688\u0694\u06c3")
        return buf.getvalue()


class SQLiteParser ( Parser ):

    grammarFileName = "SQLite.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "';'", "'.'", "'('", "')'", "','", "'='", 
                     "'*'", "'+'", "'-'", "'~'", "'||'", "'/'", "'%'", "'<<'", 
                     "'>>'", "'&'", "'|'", "'<'", "'<='", "'>'", "'>='", 
                     "'=='", "'!='", "'<>'" ]

    symbolicNames = [ "<INVALID>", "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" ]

    RULE_parse = 0
    RULE_error = 1
    RULE_sql_stmt_list = 2
    RULE_sql_stmt = 3
    RULE_alter_table_stmt = 4
    RULE_analyze_stmt = 5
    RULE_attach_stmt = 6
    RULE_begin_stmt = 7
    RULE_commit_stmt = 8
    RULE_compound_select_stmt = 9
    RULE_create_index_stmt = 10
    RULE_create_table_stmt = 11
    RULE_create_trigger_stmt = 12
    RULE_create_view_stmt = 13
    RULE_create_virtual_table_stmt = 14
    RULE_delete_stmt = 15
    RULE_delete_stmt_limited = 16
    RULE_detach_stmt = 17
    RULE_drop_index_stmt = 18
    RULE_drop_table_stmt = 19
    RULE_drop_trigger_stmt = 20
    RULE_drop_view_stmt = 21
    RULE_factored_select_stmt = 22
    RULE_insert_stmt = 23
    RULE_pragma_stmt = 24
    RULE_reindex_stmt = 25
    RULE_release_stmt = 26
    RULE_rollback_stmt = 27
    RULE_savepoint_stmt = 28
    RULE_simple_select_stmt = 29
    RULE_select_stmt = 30
    RULE_select_or_values = 31
    RULE_update_stmt = 32
    RULE_update_stmt_limited = 33
    RULE_vacuum_stmt = 34
    RULE_column_def = 35
    RULE_type_name = 36
    RULE_column_constraint = 37
    RULE_conflict_clause = 38
    RULE_expr = 39
    RULE_foreign_key_clause = 40
    RULE_raise_function = 41
    RULE_indexed_column = 42
    RULE_table_constraint = 43
    RULE_with_clause = 44
    RULE_qualified_table_name = 45
    RULE_ordering_term = 46
    RULE_pragma_value = 47
    RULE_common_table_expression = 48
    RULE_result_column = 49
    RULE_table_or_subquery = 50
    RULE_join_clause = 51
    RULE_join_operator = 52
    RULE_join_constraint = 53
    RULE_select_core = 54
    RULE_compound_operator = 55
    RULE_cte_table_name = 56
    RULE_signed_number = 57
    RULE_literal_value = 58
    RULE_unary_operator = 59
    RULE_error_message = 60
    RULE_module_argument = 61
    RULE_column_alias = 62
    RULE_keyword = 63
    RULE_name = 64
    RULE_function_name = 65
    RULE_database_name = 66
    RULE_table_name = 67
    RULE_table_or_index_name = 68
    RULE_new_table_name = 69
    RULE_column_name = 70
    RULE_collation_name = 71
    RULE_foreign_table = 72
    RULE_index_name = 73
    RULE_trigger_name = 74
    RULE_view_name = 75
    RULE_module_name = 76
    RULE_pragma_name = 77
    RULE_savepoint_name = 78
    RULE_table_alias = 79
    RULE_transaction_name = 80
    RULE_any_name = 81

    ruleNames =  [ "parse", "error", "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", "cte_table_name", "signed_number", 
                   "literal_value", "unary_operator", "error_message", "module_argument", 
                   "column_alias", "keyword", "name", "function_name", "database_name", 
                   "table_name", "table_or_index_name", "new_table_name", 
                   "column_name", "collation_name", "foreign_table", "index_name", 
                   "trigger_name", "view_name", "module_name", "pragma_name", 
                   "savepoint_name", "table_alias", "transaction_name", 
                   "any_name" ]

    EOF = Token.EOF
    SCOL=1
    DOT=2
    OPEN_PAR=3
    CLOSE_PAR=4
    COMMA=5
    ASSIGN=6
    STAR=7
    PLUS=8
    MINUS=9
    TILDE=10
    PIPE2=11
    DIV=12
    MOD=13
    LT2=14
    GT2=15
    AMP=16
    PIPE=17
    LT=18
    LT_EQ=19
    GT=20
    GT_EQ=21
    EQ=22
    NOT_EQ1=23
    NOT_EQ2=24
    K_ABORT=25
    K_ACTION=26
    K_ADD=27
    K_AFTER=28
    K_ALL=29
    K_ALTER=30
    K_ANALYZE=31
    K_AND=32
    K_AS=33
    K_ASC=34
    K_ATTACH=35
    K_AUTOINCREMENT=36
    K_BEFORE=37
    K_BEGIN=38
    K_BETWEEN=39
    K_BY=40
    K_CASCADE=41
    K_CASE=42
    K_CAST=43
    K_CHECK=44
    K_COLLATE=45
    K_COLUMN=46
    K_COMMIT=47
    K_CONFLICT=48
    K_CONSTRAINT=49
    K_CREATE=50
    K_CROSS=51
    K_CURRENT_DATE=52
    K_CURRENT_TIME=53
    K_CURRENT_TIMESTAMP=54
    K_DATABASE=55
    K_DEFAULT=56
    K_DEFERRABLE=57
    K_DEFERRED=58
    K_DELETE=59
    K_DESC=60
    K_DETACH=61
    K_DISTINCT=62
    K_DROP=63
    K_EACH=64
    K_ELSE=65
    K_END=66
    K_ESCAPE=67
    K_EXCEPT=68
    K_EXCLUSIVE=69
    K_EXISTS=70
    K_EXPLAIN=71
    K_FAIL=72
    K_FOR=73
    K_FOREIGN=74
    K_FROM=75
    K_FULL=76
    K_GLOB=77
    K_GROUP=78
    K_HAVING=79
    K_IF=80
    K_IGNORE=81
    K_IMMEDIATE=82
    K_IN=83
    K_INDEX=84
    K_INDEXED=85
    K_INITIALLY=86
    K_INNER=87
    K_INSERT=88
    K_INSTEAD=89
    K_INTERSECT=90
    K_INTO=91
    K_IS=92
    K_ISNULL=93
    K_JOIN=94
    K_KEY=95
    K_LEFT=96
    K_LIKE=97
    K_LIMIT=98
    K_MATCH=99
    K_NATURAL=100
    K_NO=101
    K_NOT=102
    K_NOTNULL=103
    K_NULL=104
    K_OF=105
    K_OFFSET=106
    K_ON=107
    K_OR=108
    K_ORDER=109
    K_OUTER=110
    K_PLAN=111
    K_PRAGMA=112
    K_PRIMARY=113
    K_QUERY=114
    K_RAISE=115
    K_RECURSIVE=116
    K_REFERENCES=117
    K_REGEXP=118
    K_REINDEX=119
    K_RELEASE=120
    K_RENAME=121
    K_REPLACE=122
    K_RESTRICT=123
    K_RIGHT=124
    K_ROLLBACK=125
    K_ROW=126
    K_SAVEPOINT=127
    K_SELECT=128
    K_SET=129
    K_TABLE=130
    K_TEMP=131
    K_TEMPORARY=132
    K_THEN=133
    K_TO=134
    K_TRANSACTION=135
    K_TRIGGER=136
    K_UNION=137
    K_UNIQUE=138
    K_UPDATE=139
    K_USING=140
    K_VACUUM=141
    K_VALUES=142
    K_VIEW=143
    K_VIRTUAL=144
    K_WHEN=145
    K_WHERE=146
    K_WITH=147
    K_WITHOUT=148
    IDENTIFIER=149
    NUMERIC_LITERAL=150
    BIND_PARAMETER=151
    STRING_LITERAL=152
    BLOB_LITERAL=153
    SINGLE_LINE_COMMENT=154
    MULTILINE_COMMENT=155
    SPACES=156
    UNEXPECTED_CHAR=157

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.8")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class ParseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(SQLiteParser.EOF, 0)

        def sql_stmt_list(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Sql_stmt_listContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Sql_stmt_listContext,i)


        def error(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ErrorContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ErrorContext,i)


        def getRuleIndex(self):
            return SQLiteParser.RULE_parse

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterParse" ):
                listener.enterParse(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitParse" ):
                listener.exitParse(self)




    def parse(self):

        localctx = SQLiteParser.ParseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_parse)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 168
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.SCOL) | (1 << SQLiteParser.K_ALTER) | (1 << SQLiteParser.K_ANALYZE) | (1 << SQLiteParser.K_ATTACH) | (1 << SQLiteParser.K_BEGIN) | (1 << SQLiteParser.K_COMMIT) | (1 << SQLiteParser.K_CREATE) | (1 << SQLiteParser.K_DELETE) | (1 << SQLiteParser.K_DETACH) | (1 << SQLiteParser.K_DROP))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (SQLiteParser.K_END - 66)) | (1 << (SQLiteParser.K_EXPLAIN - 66)) | (1 << (SQLiteParser.K_INSERT - 66)) | (1 << (SQLiteParser.K_PRAGMA - 66)) | (1 << (SQLiteParser.K_REINDEX - 66)) | (1 << (SQLiteParser.K_RELEASE - 66)) | (1 << (SQLiteParser.K_REPLACE - 66)) | (1 << (SQLiteParser.K_ROLLBACK - 66)) | (1 << (SQLiteParser.K_SAVEPOINT - 66)) | (1 << (SQLiteParser.K_SELECT - 66)))) != 0) or ((((_la - 139)) & ~0x3f) == 0 and ((1 << (_la - 139)) & ((1 << (SQLiteParser.K_UPDATE - 139)) | (1 << (SQLiteParser.K_VACUUM - 139)) | (1 << (SQLiteParser.K_VALUES - 139)) | (1 << (SQLiteParser.K_WITH - 139)) | (1 << (SQLiteParser.UNEXPECTED_CHAR - 139)))) != 0):
                self.state = 166
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.SCOL, SQLiteParser.K_ALTER, SQLiteParser.K_ANALYZE, SQLiteParser.K_ATTACH, SQLiteParser.K_BEGIN, SQLiteParser.K_COMMIT, SQLiteParser.K_CREATE, SQLiteParser.K_DELETE, SQLiteParser.K_DETACH, SQLiteParser.K_DROP, SQLiteParser.K_END, SQLiteParser.K_EXPLAIN, SQLiteParser.K_INSERT, SQLiteParser.K_PRAGMA, SQLiteParser.K_REINDEX, SQLiteParser.K_RELEASE, SQLiteParser.K_REPLACE, SQLiteParser.K_ROLLBACK, SQLiteParser.K_SAVEPOINT, SQLiteParser.K_SELECT, SQLiteParser.K_UPDATE, SQLiteParser.K_VACUUM, SQLiteParser.K_VALUES, SQLiteParser.K_WITH]:
                    self.state = 164
                    self.sql_stmt_list()
                    pass
                elif token in [SQLiteParser.UNEXPECTED_CHAR]:
                    self.state = 165
                    self.error()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 170
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 171
            self.match(SQLiteParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ErrorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self._UNEXPECTED_CHAR = None # Token

        def UNEXPECTED_CHAR(self):
            return self.getToken(SQLiteParser.UNEXPECTED_CHAR, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_error

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterError" ):
                listener.enterError(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitError" ):
                listener.exitError(self)




    def error(self):

        localctx = SQLiteParser.ErrorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_error)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 173
            localctx._UNEXPECTED_CHAR = self.match(SQLiteParser.UNEXPECTED_CHAR)
             
            raise SyntaxError("UNEXPECTED_CHAR=" + (None if localctx._UNEXPECTED_CHAR is None else localctx._UNEXPECTED_CHAR.text)); 
               
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Sql_stmt_listContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def sql_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Sql_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Sql_stmtContext,i)


        def SCOL(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.SCOL)
            else:
                return self.getToken(SQLiteParser.SCOL, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_sql_stmt_list

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSql_stmt_list" ):
                listener.enterSql_stmt_list(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSql_stmt_list" ):
                listener.exitSql_stmt_list(self)




    def sql_stmt_list(self):

        localctx = SQLiteParser.Sql_stmt_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_sql_stmt_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 179
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.SCOL:
                self.state = 176
                self.match(SQLiteParser.SCOL)
                self.state = 181
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 182
            self.sql_stmt()
            self.state = 191
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,4,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 184 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 183
                        self.match(SQLiteParser.SCOL)
                        self.state = 186 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==SQLiteParser.SCOL):
                            break

                    self.state = 188
                    self.sql_stmt() 
                self.state = 193
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,4,self._ctx)

            self.state = 197
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 194
                    self.match(SQLiteParser.SCOL) 
                self.state = 199
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,5,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Sql_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def alter_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Alter_table_stmtContext,0)


        def analyze_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Analyze_stmtContext,0)


        def attach_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Attach_stmtContext,0)


        def begin_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Begin_stmtContext,0)


        def commit_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Commit_stmtContext,0)


        def compound_select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Compound_select_stmtContext,0)


        def create_index_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_index_stmtContext,0)


        def create_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_table_stmtContext,0)


        def create_trigger_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_trigger_stmtContext,0)


        def create_view_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_view_stmtContext,0)


        def create_virtual_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Create_virtual_table_stmtContext,0)


        def delete_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Delete_stmtContext,0)


        def delete_stmt_limited(self):
            return self.getTypedRuleContext(SQLiteParser.Delete_stmt_limitedContext,0)


        def detach_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Detach_stmtContext,0)


        def drop_index_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Drop_index_stmtContext,0)


        def drop_table_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Drop_table_stmtContext,0)


        def drop_trigger_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Drop_trigger_stmtContext,0)


        def drop_view_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Drop_view_stmtContext,0)


        def factored_select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Factored_select_stmtContext,0)


        def insert_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Insert_stmtContext,0)


        def pragma_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Pragma_stmtContext,0)


        def reindex_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Reindex_stmtContext,0)


        def release_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Release_stmtContext,0)


        def rollback_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Rollback_stmtContext,0)


        def savepoint_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Savepoint_stmtContext,0)


        def simple_select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Simple_select_stmtContext,0)


        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def update_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Update_stmtContext,0)


        def update_stmt_limited(self):
            return self.getTypedRuleContext(SQLiteParser.Update_stmt_limitedContext,0)


        def vacuum_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Vacuum_stmtContext,0)


        def K_EXPLAIN(self):
            return self.getToken(SQLiteParser.K_EXPLAIN, 0)

        def K_QUERY(self):
            return self.getToken(SQLiteParser.K_QUERY, 0)

        def K_PLAN(self):
            return self.getToken(SQLiteParser.K_PLAN, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_sql_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSql_stmt" ):
                listener.enterSql_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSql_stmt" ):
                listener.exitSql_stmt(self)




    def sql_stmt(self):

        localctx = SQLiteParser.Sql_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_sql_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 205
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_EXPLAIN:
                self.state = 200
                self.match(SQLiteParser.K_EXPLAIN)
                self.state = 203
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_QUERY:
                    self.state = 201
                    self.match(SQLiteParser.K_QUERY)
                    self.state = 202
                    self.match(SQLiteParser.K_PLAN)




            self.state = 237
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.state = 207
                self.alter_table_stmt()
                pass

            elif la_ == 2:
                self.state = 208
                self.analyze_stmt()
                pass

            elif la_ == 3:
                self.state = 209
                self.attach_stmt()
                pass

            elif la_ == 4:
                self.state = 210
                self.begin_stmt()
                pass

            elif la_ == 5:
                self.state = 211
                self.commit_stmt()
                pass

            elif la_ == 6:
                self.state = 212
                self.compound_select_stmt()
                pass

            elif la_ == 7:
                self.state = 213
                self.create_index_stmt()
                pass

            elif la_ == 8:
                self.state = 214
                self.create_table_stmt()
                pass

            elif la_ == 9:
                self.state = 215
                self.create_trigger_stmt()
                pass

            elif la_ == 10:
                self.state = 216
                self.create_view_stmt()
                pass

            elif la_ == 11:
                self.state = 217
                self.create_virtual_table_stmt()
                pass

            elif la_ == 12:
                self.state = 218
                self.delete_stmt()
                pass

            elif la_ == 13:
                self.state = 219
                self.delete_stmt_limited()
                pass

            elif la_ == 14:
                self.state = 220
                self.detach_stmt()
                pass

            elif la_ == 15:
                self.state = 221
                self.drop_index_stmt()
                pass

            elif la_ == 16:
                self.state = 222
                self.drop_table_stmt()
                pass

            elif la_ == 17:
                self.state = 223
                self.drop_trigger_stmt()
                pass

            elif la_ == 18:
                self.state = 224
                self.drop_view_stmt()
                pass

            elif la_ == 19:
                self.state = 225
                self.factored_select_stmt()
                pass

            elif la_ == 20:
                self.state = 226
                self.insert_stmt()
                pass

            elif la_ == 21:
                self.state = 227
                self.pragma_stmt()
                pass

            elif la_ == 22:
                self.state = 228
                self.reindex_stmt()
                pass

            elif la_ == 23:
                self.state = 229
                self.release_stmt()
                pass

            elif la_ == 24:
                self.state = 230
                self.rollback_stmt()
                pass

            elif la_ == 25:
                self.state = 231
                self.savepoint_stmt()
                pass

            elif la_ == 26:
                self.state = 232
                self.simple_select_stmt()
                pass

            elif la_ == 27:
                self.state = 233
                self.select_stmt()
                pass

            elif la_ == 28:
                self.state = 234
                self.update_stmt()
                pass

            elif la_ == 29:
                self.state = 235
                self.update_stmt_limited()
                pass

            elif la_ == 30:
                self.state = 236
                self.vacuum_stmt()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Alter_table_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_ALTER(self):
            return self.getToken(SQLiteParser.K_ALTER, 0)

        def K_TABLE(self):
            return self.getToken(SQLiteParser.K_TABLE, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def K_RENAME(self):
            return self.getToken(SQLiteParser.K_RENAME, 0)

        def K_TO(self):
            return self.getToken(SQLiteParser.K_TO, 0)

        def new_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.New_table_nameContext,0)


        def K_ADD(self):
            return self.getToken(SQLiteParser.K_ADD, 0)

        def column_def(self):
            return self.getTypedRuleContext(SQLiteParser.Column_defContext,0)


        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def K_COLUMN(self):
            return self.getToken(SQLiteParser.K_COLUMN, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_alter_table_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAlter_table_stmt" ):
                listener.enterAlter_table_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAlter_table_stmt" ):
                listener.exitAlter_table_stmt(self)




    def alter_table_stmt(self):

        localctx = SQLiteParser.Alter_table_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_alter_table_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 239
            self.match(SQLiteParser.K_ALTER)
            self.state = 240
            self.match(SQLiteParser.K_TABLE)
            self.state = 244
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,9,self._ctx)
            if la_ == 1:
                self.state = 241
                self.database_name()
                self.state = 242
                self.match(SQLiteParser.DOT)


            self.state = 246
            self.table_name()
            self.state = 255
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_RENAME]:
                self.state = 247
                self.match(SQLiteParser.K_RENAME)
                self.state = 248
                self.match(SQLiteParser.K_TO)
                self.state = 249
                self.new_table_name()
                pass
            elif token in [SQLiteParser.K_ADD]:
                self.state = 250
                self.match(SQLiteParser.K_ADD)
                self.state = 252
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
                if la_ == 1:
                    self.state = 251
                    self.match(SQLiteParser.K_COLUMN)


                self.state = 254
                self.column_def()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Analyze_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_ANALYZE(self):
            return self.getToken(SQLiteParser.K_ANALYZE, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def table_or_index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_or_index_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_analyze_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAnalyze_stmt" ):
                listener.enterAnalyze_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAnalyze_stmt" ):
                listener.exitAnalyze_stmt(self)




    def analyze_stmt(self):

        localctx = SQLiteParser.Analyze_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_analyze_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 257
            self.match(SQLiteParser.K_ANALYZE)
            self.state = 264
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.state = 258
                self.database_name()

            elif la_ == 2:
                self.state = 259
                self.table_or_index_name()

            elif la_ == 3:
                self.state = 260
                self.database_name()
                self.state = 261
                self.match(SQLiteParser.DOT)
                self.state = 262
                self.table_or_index_name()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Attach_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_ATTACH(self):
            return self.getToken(SQLiteParser.K_ATTACH, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def K_AS(self):
            return self.getToken(SQLiteParser.K_AS, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def K_DATABASE(self):
            return self.getToken(SQLiteParser.K_DATABASE, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_attach_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAttach_stmt" ):
                listener.enterAttach_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAttach_stmt" ):
                listener.exitAttach_stmt(self)




    def attach_stmt(self):

        localctx = SQLiteParser.Attach_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_attach_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 266
            self.match(SQLiteParser.K_ATTACH)
            self.state = 268
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.state = 267
                self.match(SQLiteParser.K_DATABASE)


            self.state = 270
            self.expr(0)
            self.state = 271
            self.match(SQLiteParser.K_AS)
            self.state = 272
            self.database_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Begin_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_BEGIN(self):
            return self.getToken(SQLiteParser.K_BEGIN, 0)

        def K_TRANSACTION(self):
            return self.getToken(SQLiteParser.K_TRANSACTION, 0)

        def K_DEFERRED(self):
            return self.getToken(SQLiteParser.K_DEFERRED, 0)

        def K_IMMEDIATE(self):
            return self.getToken(SQLiteParser.K_IMMEDIATE, 0)

        def K_EXCLUSIVE(self):
            return self.getToken(SQLiteParser.K_EXCLUSIVE, 0)

        def transaction_name(self):
            return self.getTypedRuleContext(SQLiteParser.Transaction_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_begin_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBegin_stmt" ):
                listener.enterBegin_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBegin_stmt" ):
                listener.exitBegin_stmt(self)




    def begin_stmt(self):

        localctx = SQLiteParser.Begin_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_begin_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 274
            self.match(SQLiteParser.K_BEGIN)
            self.state = 276
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & ((1 << (SQLiteParser.K_DEFERRED - 58)) | (1 << (SQLiteParser.K_EXCLUSIVE - 58)) | (1 << (SQLiteParser.K_IMMEDIATE - 58)))) != 0):
                self.state = 275
                _la = self._input.LA(1)
                if not(((((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & ((1 << (SQLiteParser.K_DEFERRED - 58)) | (1 << (SQLiteParser.K_EXCLUSIVE - 58)) | (1 << (SQLiteParser.K_IMMEDIATE - 58)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 282
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_TRANSACTION:
                self.state = 278
                self.match(SQLiteParser.K_TRANSACTION)
                self.state = 280
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
                if la_ == 1:
                    self.state = 279
                    self.transaction_name()




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Commit_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_COMMIT(self):
            return self.getToken(SQLiteParser.K_COMMIT, 0)

        def K_END(self):
            return self.getToken(SQLiteParser.K_END, 0)

        def K_TRANSACTION(self):
            return self.getToken(SQLiteParser.K_TRANSACTION, 0)

        def transaction_name(self):
            return self.getTypedRuleContext(SQLiteParser.Transaction_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_commit_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCommit_stmt" ):
                listener.enterCommit_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCommit_stmt" ):
                listener.exitCommit_stmt(self)




    def commit_stmt(self):

        localctx = SQLiteParser.Commit_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_commit_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 284
            _la = self._input.LA(1)
            if not(_la==SQLiteParser.K_COMMIT or _la==SQLiteParser.K_END):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 289
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_TRANSACTION:
                self.state = 285
                self.match(SQLiteParser.K_TRANSACTION)
                self.state = 287
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
                if la_ == 1:
                    self.state = 286
                    self.transaction_name()




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Compound_select_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def select_core(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Select_coreContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Select_coreContext,i)


        def K_WITH(self):
            return self.getToken(SQLiteParser.K_WITH, 0)

        def common_table_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Common_table_expressionContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Common_table_expressionContext,i)


        def K_ORDER(self):
            return self.getToken(SQLiteParser.K_ORDER, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def ordering_term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i)


        def K_LIMIT(self):
            return self.getToken(SQLiteParser.K_LIMIT, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def K_UNION(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_UNION)
            else:
                return self.getToken(SQLiteParser.K_UNION, i)

        def K_INTERSECT(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_INTERSECT)
            else:
                return self.getToken(SQLiteParser.K_INTERSECT, i)

        def K_EXCEPT(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_EXCEPT)
            else:
                return self.getToken(SQLiteParser.K_EXCEPT, i)

        def K_RECURSIVE(self):
            return self.getToken(SQLiteParser.K_RECURSIVE, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_OFFSET(self):
            return self.getToken(SQLiteParser.K_OFFSET, 0)

        def K_ALL(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_ALL)
            else:
                return self.getToken(SQLiteParser.K_ALL, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_compound_select_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCompound_select_stmt" ):
                listener.enterCompound_select_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCompound_select_stmt" ):
                listener.exitCompound_select_stmt(self)




    def compound_select_stmt(self):

        localctx = SQLiteParser.Compound_select_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_compound_select_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 303
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WITH:
                self.state = 291
                self.match(SQLiteParser.K_WITH)
                self.state = 293
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
                if la_ == 1:
                    self.state = 292
                    self.match(SQLiteParser.K_RECURSIVE)


                self.state = 295
                self.common_table_expression()
                self.state = 300
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 296
                    self.match(SQLiteParser.COMMA)
                    self.state = 297
                    self.common_table_expression()
                    self.state = 302
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 305
            self.select_core()
            self.state = 315 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 312
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.K_UNION]:
                    self.state = 306
                    self.match(SQLiteParser.K_UNION)
                    self.state = 308
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.K_ALL:
                        self.state = 307
                        self.match(SQLiteParser.K_ALL)


                    pass
                elif token in [SQLiteParser.K_INTERSECT]:
                    self.state = 310
                    self.match(SQLiteParser.K_INTERSECT)
                    pass
                elif token in [SQLiteParser.K_EXCEPT]:
                    self.state = 311
                    self.match(SQLiteParser.K_EXCEPT)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 314
                self.select_core()
                self.state = 317 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SQLiteParser.K_EXCEPT or _la==SQLiteParser.K_INTERSECT or _la==SQLiteParser.K_UNION):
                    break

            self.state = 329
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_ORDER:
                self.state = 319
                self.match(SQLiteParser.K_ORDER)
                self.state = 320
                self.match(SQLiteParser.K_BY)
                self.state = 321
                self.ordering_term()
                self.state = 326
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 322
                    self.match(SQLiteParser.COMMA)
                    self.state = 323
                    self.ordering_term()
                    self.state = 328
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 337
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_LIMIT:
                self.state = 331
                self.match(SQLiteParser.K_LIMIT)
                self.state = 332
                self.expr(0)
                self.state = 335
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET:
                    self.state = 333
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 334
                    self.expr(0)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Create_index_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_CREATE(self):
            return self.getToken(SQLiteParser.K_CREATE, 0)

        def K_INDEX(self):
            return self.getToken(SQLiteParser.K_INDEX, 0)

        def index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0)


        def K_ON(self):
            return self.getToken(SQLiteParser.K_ON, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def indexed_column(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Indexed_columnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Indexed_columnContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def K_UNIQUE(self):
            return self.getToken(SQLiteParser.K_UNIQUE, 0)

        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_WHERE(self):
            return self.getToken(SQLiteParser.K_WHERE, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_create_index_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreate_index_stmt" ):
                listener.enterCreate_index_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreate_index_stmt" ):
                listener.exitCreate_index_stmt(self)




    def create_index_stmt(self):

        localctx = SQLiteParser.Create_index_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_create_index_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 339
            self.match(SQLiteParser.K_CREATE)
            self.state = 341
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_UNIQUE:
                self.state = 340
                self.match(SQLiteParser.K_UNIQUE)


            self.state = 343
            self.match(SQLiteParser.K_INDEX)
            self.state = 347
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.state = 344
                self.match(SQLiteParser.K_IF)
                self.state = 345
                self.match(SQLiteParser.K_NOT)
                self.state = 346
                self.match(SQLiteParser.K_EXISTS)


            self.state = 352
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
            if la_ == 1:
                self.state = 349
                self.database_name()
                self.state = 350
                self.match(SQLiteParser.DOT)


            self.state = 354
            self.index_name()
            self.state = 355
            self.match(SQLiteParser.K_ON)
            self.state = 356
            self.table_name()
            self.state = 357
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 358
            self.indexed_column()
            self.state = 363
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 359
                self.match(SQLiteParser.COMMA)
                self.state = 360
                self.indexed_column()
                self.state = 365
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 366
            self.match(SQLiteParser.CLOSE_PAR)
            self.state = 369
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WHERE:
                self.state = 367
                self.match(SQLiteParser.K_WHERE)
                self.state = 368
                self.expr(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Create_table_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_CREATE(self):
            return self.getToken(SQLiteParser.K_CREATE, 0)

        def K_TABLE(self):
            return self.getToken(SQLiteParser.K_TABLE, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_def(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_defContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_defContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def K_AS(self):
            return self.getToken(SQLiteParser.K_AS, 0)

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def K_TEMP(self):
            return self.getToken(SQLiteParser.K_TEMP, 0)

        def K_TEMPORARY(self):
            return self.getToken(SQLiteParser.K_TEMPORARY, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def table_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_constraintContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_constraintContext,i)


        def K_WITHOUT(self):
            return self.getToken(SQLiteParser.K_WITHOUT, 0)

        def IDENTIFIER(self):
            return self.getToken(SQLiteParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_create_table_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreate_table_stmt" ):
                listener.enterCreate_table_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreate_table_stmt" ):
                listener.exitCreate_table_stmt(self)




    def create_table_stmt(self):

        localctx = SQLiteParser.Create_table_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_create_table_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 371
            self.match(SQLiteParser.K_CREATE)
            self.state = 373
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_TEMP or _la==SQLiteParser.K_TEMPORARY:
                self.state = 372
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.K_TEMP or _la==SQLiteParser.K_TEMPORARY):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 375
            self.match(SQLiteParser.K_TABLE)
            self.state = 379
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.state = 376
                self.match(SQLiteParser.K_IF)
                self.state = 377
                self.match(SQLiteParser.K_NOT)
                self.state = 378
                self.match(SQLiteParser.K_EXISTS)


            self.state = 384
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.state = 381
                self.database_name()
                self.state = 382
                self.match(SQLiteParser.DOT)


            self.state = 386
            self.table_name()
            self.state = 410
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.OPEN_PAR]:
                self.state = 387
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 388
                self.column_def()
                self.state = 393
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,37,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 389
                        self.match(SQLiteParser.COMMA)
                        self.state = 390
                        self.column_def() 
                    self.state = 395
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,37,self._ctx)

                self.state = 400
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 396
                    self.match(SQLiteParser.COMMA)
                    self.state = 397
                    self.table_constraint()
                    self.state = 402
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 403
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 406
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_WITHOUT:
                    self.state = 404
                    self.match(SQLiteParser.K_WITHOUT)
                    self.state = 405
                    self.match(SQLiteParser.IDENTIFIER)


                pass
            elif token in [SQLiteParser.K_AS]:
                self.state = 408
                self.match(SQLiteParser.K_AS)
                self.state = 409
                self.select_stmt()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Create_trigger_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_CREATE(self):
            return self.getToken(SQLiteParser.K_CREATE, 0)

        def K_TRIGGER(self):
            return self.getToken(SQLiteParser.K_TRIGGER, 0)

        def trigger_name(self):
            return self.getTypedRuleContext(SQLiteParser.Trigger_nameContext,0)


        def K_ON(self):
            return self.getToken(SQLiteParser.K_ON, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def K_BEGIN(self):
            return self.getToken(SQLiteParser.K_BEGIN, 0)

        def K_END(self):
            return self.getToken(SQLiteParser.K_END, 0)

        def K_DELETE(self):
            return self.getToken(SQLiteParser.K_DELETE, 0)

        def K_INSERT(self):
            return self.getToken(SQLiteParser.K_INSERT, 0)

        def K_UPDATE(self):
            return self.getToken(SQLiteParser.K_UPDATE, 0)

        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def database_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Database_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Database_nameContext,i)


        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.DOT)
            else:
                return self.getToken(SQLiteParser.DOT, i)

        def K_BEFORE(self):
            return self.getToken(SQLiteParser.K_BEFORE, 0)

        def K_AFTER(self):
            return self.getToken(SQLiteParser.K_AFTER, 0)

        def K_INSTEAD(self):
            return self.getToken(SQLiteParser.K_INSTEAD, 0)

        def K_OF(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_OF)
            else:
                return self.getToken(SQLiteParser.K_OF, i)

        def K_FOR(self):
            return self.getToken(SQLiteParser.K_FOR, 0)

        def K_EACH(self):
            return self.getToken(SQLiteParser.K_EACH, 0)

        def K_ROW(self):
            return self.getToken(SQLiteParser.K_ROW, 0)

        def K_WHEN(self):
            return self.getToken(SQLiteParser.K_WHEN, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def SCOL(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.SCOL)
            else:
                return self.getToken(SQLiteParser.SCOL, i)

        def K_TEMP(self):
            return self.getToken(SQLiteParser.K_TEMP, 0)

        def K_TEMPORARY(self):
            return self.getToken(SQLiteParser.K_TEMPORARY, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def update_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Update_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Update_stmtContext,i)


        def insert_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Insert_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Insert_stmtContext,i)


        def delete_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Delete_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Delete_stmtContext,i)


        def select_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Select_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_create_trigger_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreate_trigger_stmt" ):
                listener.enterCreate_trigger_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreate_trigger_stmt" ):
                listener.exitCreate_trigger_stmt(self)




    def create_trigger_stmt(self):

        localctx = SQLiteParser.Create_trigger_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_create_trigger_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 412
            self.match(SQLiteParser.K_CREATE)
            self.state = 414
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_TEMP or _la==SQLiteParser.K_TEMPORARY:
                self.state = 413
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.K_TEMP or _la==SQLiteParser.K_TEMPORARY):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 416
            self.match(SQLiteParser.K_TRIGGER)
            self.state = 420
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.state = 417
                self.match(SQLiteParser.K_IF)
                self.state = 418
                self.match(SQLiteParser.K_NOT)
                self.state = 419
                self.match(SQLiteParser.K_EXISTS)


            self.state = 425
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
            if la_ == 1:
                self.state = 422
                self.database_name()
                self.state = 423
                self.match(SQLiteParser.DOT)


            self.state = 427
            self.trigger_name()
            self.state = 432
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_BEFORE]:
                self.state = 428
                self.match(SQLiteParser.K_BEFORE)
                pass
            elif token in [SQLiteParser.K_AFTER]:
                self.state = 429
                self.match(SQLiteParser.K_AFTER)
                pass
            elif token in [SQLiteParser.K_INSTEAD]:
                self.state = 430
                self.match(SQLiteParser.K_INSTEAD)
                self.state = 431
                self.match(SQLiteParser.K_OF)
                pass
            elif token in [SQLiteParser.K_DELETE, SQLiteParser.K_INSERT, SQLiteParser.K_UPDATE]:
                pass
            else:
                pass
            self.state = 448
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_DELETE]:
                self.state = 434
                self.match(SQLiteParser.K_DELETE)
                pass
            elif token in [SQLiteParser.K_INSERT]:
                self.state = 435
                self.match(SQLiteParser.K_INSERT)
                pass
            elif token in [SQLiteParser.K_UPDATE]:
                self.state = 436
                self.match(SQLiteParser.K_UPDATE)
                self.state = 446
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_OF:
                    self.state = 437
                    self.match(SQLiteParser.K_OF)
                    self.state = 438
                    self.column_name()
                    self.state = 443
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 439
                        self.match(SQLiteParser.COMMA)
                        self.state = 440
                        self.column_name()
                        self.state = 445
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                pass
            else:
                raise NoViableAltException(self)

            self.state = 450
            self.match(SQLiteParser.K_ON)
            self.state = 454
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
            if la_ == 1:
                self.state = 451
                self.database_name()
                self.state = 452
                self.match(SQLiteParser.DOT)


            self.state = 456
            self.table_name()
            self.state = 460
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_FOR:
                self.state = 457
                self.match(SQLiteParser.K_FOR)
                self.state = 458
                self.match(SQLiteParser.K_EACH)
                self.state = 459
                self.match(SQLiteParser.K_ROW)


            self.state = 464
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WHEN:
                self.state = 462
                self.match(SQLiteParser.K_WHEN)
                self.state = 463
                self.expr(0)


            self.state = 466
            self.match(SQLiteParser.K_BEGIN)
            self.state = 475 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 471
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,51,self._ctx)
                if la_ == 1:
                    self.state = 467
                    self.update_stmt()
                    pass

                elif la_ == 2:
                    self.state = 468
                    self.insert_stmt()
                    pass

                elif la_ == 3:
                    self.state = 469
                    self.delete_stmt()
                    pass

                elif la_ == 4:
                    self.state = 470
                    self.select_stmt()
                    pass


                self.state = 473
                self.match(SQLiteParser.SCOL)
                self.state = 477 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==SQLiteParser.K_DELETE or ((((_la - 88)) & ~0x3f) == 0 and ((1 << (_la - 88)) & ((1 << (SQLiteParser.K_INSERT - 88)) | (1 << (SQLiteParser.K_REPLACE - 88)) | (1 << (SQLiteParser.K_SELECT - 88)) | (1 << (SQLiteParser.K_UPDATE - 88)) | (1 << (SQLiteParser.K_VALUES - 88)) | (1 << (SQLiteParser.K_WITH - 88)))) != 0)):
                    break

            self.state = 479
            self.match(SQLiteParser.K_END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Create_view_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_CREATE(self):
            return self.getToken(SQLiteParser.K_CREATE, 0)

        def K_VIEW(self):
            return self.getToken(SQLiteParser.K_VIEW, 0)

        def view_name(self):
            return self.getTypedRuleContext(SQLiteParser.View_nameContext,0)


        def K_AS(self):
            return self.getToken(SQLiteParser.K_AS, 0)

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def K_TEMP(self):
            return self.getToken(SQLiteParser.K_TEMP, 0)

        def K_TEMPORARY(self):
            return self.getToken(SQLiteParser.K_TEMPORARY, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_create_view_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreate_view_stmt" ):
                listener.enterCreate_view_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreate_view_stmt" ):
                listener.exitCreate_view_stmt(self)




    def create_view_stmt(self):

        localctx = SQLiteParser.Create_view_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_create_view_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 481
            self.match(SQLiteParser.K_CREATE)
            self.state = 483
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_TEMP or _la==SQLiteParser.K_TEMPORARY:
                self.state = 482
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.K_TEMP or _la==SQLiteParser.K_TEMPORARY):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 485
            self.match(SQLiteParser.K_VIEW)
            self.state = 489
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.state = 486
                self.match(SQLiteParser.K_IF)
                self.state = 487
                self.match(SQLiteParser.K_NOT)
                self.state = 488
                self.match(SQLiteParser.K_EXISTS)


            self.state = 494
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.state = 491
                self.database_name()
                self.state = 492
                self.match(SQLiteParser.DOT)


            self.state = 496
            self.view_name()
            self.state = 497
            self.match(SQLiteParser.K_AS)
            self.state = 498
            self.select_stmt()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Create_virtual_table_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_CREATE(self):
            return self.getToken(SQLiteParser.K_CREATE, 0)

        def K_VIRTUAL(self):
            return self.getToken(SQLiteParser.K_VIRTUAL, 0)

        def K_TABLE(self):
            return self.getToken(SQLiteParser.K_TABLE, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def K_USING(self):
            return self.getToken(SQLiteParser.K_USING, 0)

        def module_name(self):
            return self.getTypedRuleContext(SQLiteParser.Module_nameContext,0)


        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def module_argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Module_argumentContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Module_argumentContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_create_virtual_table_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCreate_virtual_table_stmt" ):
                listener.enterCreate_virtual_table_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCreate_virtual_table_stmt" ):
                listener.exitCreate_virtual_table_stmt(self)




    def create_virtual_table_stmt(self):

        localctx = SQLiteParser.Create_virtual_table_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_create_virtual_table_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 500
            self.match(SQLiteParser.K_CREATE)
            self.state = 501
            self.match(SQLiteParser.K_VIRTUAL)
            self.state = 502
            self.match(SQLiteParser.K_TABLE)
            self.state = 506
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
            if la_ == 1:
                self.state = 503
                self.match(SQLiteParser.K_IF)
                self.state = 504
                self.match(SQLiteParser.K_NOT)
                self.state = 505
                self.match(SQLiteParser.K_EXISTS)


            self.state = 511
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
            if la_ == 1:
                self.state = 508
                self.database_name()
                self.state = 509
                self.match(SQLiteParser.DOT)


            self.state = 513
            self.table_name()
            self.state = 514
            self.match(SQLiteParser.K_USING)
            self.state = 515
            self.module_name()
            self.state = 527
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 516
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 517
                self.module_argument()
                self.state = 522
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 518
                    self.match(SQLiteParser.COMMA)
                    self.state = 519
                    self.module_argument()
                    self.state = 524
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 525
                self.match(SQLiteParser.CLOSE_PAR)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Delete_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_DELETE(self):
            return self.getToken(SQLiteParser.K_DELETE, 0)

        def K_FROM(self):
            return self.getToken(SQLiteParser.K_FROM, 0)

        def qualified_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0)


        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def K_WHERE(self):
            return self.getToken(SQLiteParser.K_WHERE, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_delete_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDelete_stmt" ):
                listener.enterDelete_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDelete_stmt" ):
                listener.exitDelete_stmt(self)




    def delete_stmt(self):

        localctx = SQLiteParser.Delete_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_delete_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 530
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WITH:
                self.state = 529
                self.with_clause()


            self.state = 532
            self.match(SQLiteParser.K_DELETE)
            self.state = 533
            self.match(SQLiteParser.K_FROM)
            self.state = 534
            self.qualified_table_name()
            self.state = 537
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WHERE:
                self.state = 535
                self.match(SQLiteParser.K_WHERE)
                self.state = 536
                self.expr(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Delete_stmt_limitedContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_DELETE(self):
            return self.getToken(SQLiteParser.K_DELETE, 0)

        def K_FROM(self):
            return self.getToken(SQLiteParser.K_FROM, 0)

        def qualified_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0)


        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def K_WHERE(self):
            return self.getToken(SQLiteParser.K_WHERE, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def K_LIMIT(self):
            return self.getToken(SQLiteParser.K_LIMIT, 0)

        def K_ORDER(self):
            return self.getToken(SQLiteParser.K_ORDER, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def ordering_term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i)


        def K_OFFSET(self):
            return self.getToken(SQLiteParser.K_OFFSET, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_delete_stmt_limited

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDelete_stmt_limited" ):
                listener.enterDelete_stmt_limited(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDelete_stmt_limited" ):
                listener.exitDelete_stmt_limited(self)




    def delete_stmt_limited(self):

        localctx = SQLiteParser.Delete_stmt_limitedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_delete_stmt_limited)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 540
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WITH:
                self.state = 539
                self.with_clause()


            self.state = 542
            self.match(SQLiteParser.K_DELETE)
            self.state = 543
            self.match(SQLiteParser.K_FROM)
            self.state = 544
            self.qualified_table_name()
            self.state = 547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WHERE:
                self.state = 545
                self.match(SQLiteParser.K_WHERE)
                self.state = 546
                self.expr(0)


            self.state = 567
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_LIMIT or _la==SQLiteParser.K_ORDER:
                self.state = 559
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_ORDER:
                    self.state = 549
                    self.match(SQLiteParser.K_ORDER)
                    self.state = 550
                    self.match(SQLiteParser.K_BY)
                    self.state = 551
                    self.ordering_term()
                    self.state = 556
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 552
                        self.match(SQLiteParser.COMMA)
                        self.state = 553
                        self.ordering_term()
                        self.state = 558
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 561
                self.match(SQLiteParser.K_LIMIT)
                self.state = 562
                self.expr(0)
                self.state = 565
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET:
                    self.state = 563
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 564
                    self.expr(0)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Detach_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_DETACH(self):
            return self.getToken(SQLiteParser.K_DETACH, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def K_DATABASE(self):
            return self.getToken(SQLiteParser.K_DATABASE, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_detach_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDetach_stmt" ):
                listener.enterDetach_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDetach_stmt" ):
                listener.exitDetach_stmt(self)




    def detach_stmt(self):

        localctx = SQLiteParser.Detach_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_detach_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 569
            self.match(SQLiteParser.K_DETACH)
            self.state = 571
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,68,self._ctx)
            if la_ == 1:
                self.state = 570
                self.match(SQLiteParser.K_DATABASE)


            self.state = 573
            self.database_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Drop_index_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_DROP(self):
            return self.getToken(SQLiteParser.K_DROP, 0)

        def K_INDEX(self):
            return self.getToken(SQLiteParser.K_INDEX, 0)

        def index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0)


        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_drop_index_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDrop_index_stmt" ):
                listener.enterDrop_index_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDrop_index_stmt" ):
                listener.exitDrop_index_stmt(self)




    def drop_index_stmt(self):

        localctx = SQLiteParser.Drop_index_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_drop_index_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 575
            self.match(SQLiteParser.K_DROP)
            self.state = 576
            self.match(SQLiteParser.K_INDEX)
            self.state = 579
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.state = 577
                self.match(SQLiteParser.K_IF)
                self.state = 578
                self.match(SQLiteParser.K_EXISTS)


            self.state = 584
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,70,self._ctx)
            if la_ == 1:
                self.state = 581
                self.database_name()
                self.state = 582
                self.match(SQLiteParser.DOT)


            self.state = 586
            self.index_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Drop_table_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_DROP(self):
            return self.getToken(SQLiteParser.K_DROP, 0)

        def K_TABLE(self):
            return self.getToken(SQLiteParser.K_TABLE, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_drop_table_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDrop_table_stmt" ):
                listener.enterDrop_table_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDrop_table_stmt" ):
                listener.exitDrop_table_stmt(self)




    def drop_table_stmt(self):

        localctx = SQLiteParser.Drop_table_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_drop_table_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 588
            self.match(SQLiteParser.K_DROP)
            self.state = 589
            self.match(SQLiteParser.K_TABLE)
            self.state = 592
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.state = 590
                self.match(SQLiteParser.K_IF)
                self.state = 591
                self.match(SQLiteParser.K_EXISTS)


            self.state = 597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
            if la_ == 1:
                self.state = 594
                self.database_name()
                self.state = 595
                self.match(SQLiteParser.DOT)


            self.state = 599
            self.table_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Drop_trigger_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_DROP(self):
            return self.getToken(SQLiteParser.K_DROP, 0)

        def K_TRIGGER(self):
            return self.getToken(SQLiteParser.K_TRIGGER, 0)

        def trigger_name(self):
            return self.getTypedRuleContext(SQLiteParser.Trigger_nameContext,0)


        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_drop_trigger_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDrop_trigger_stmt" ):
                listener.enterDrop_trigger_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDrop_trigger_stmt" ):
                listener.exitDrop_trigger_stmt(self)




    def drop_trigger_stmt(self):

        localctx = SQLiteParser.Drop_trigger_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_drop_trigger_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 601
            self.match(SQLiteParser.K_DROP)
            self.state = 602
            self.match(SQLiteParser.K_TRIGGER)
            self.state = 605
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.state = 603
                self.match(SQLiteParser.K_IF)
                self.state = 604
                self.match(SQLiteParser.K_EXISTS)


            self.state = 610
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.state = 607
                self.database_name()
                self.state = 608
                self.match(SQLiteParser.DOT)


            self.state = 612
            self.trigger_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Drop_view_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_DROP(self):
            return self.getToken(SQLiteParser.K_DROP, 0)

        def K_VIEW(self):
            return self.getToken(SQLiteParser.K_VIEW, 0)

        def view_name(self):
            return self.getTypedRuleContext(SQLiteParser.View_nameContext,0)


        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_drop_view_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDrop_view_stmt" ):
                listener.enterDrop_view_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDrop_view_stmt" ):
                listener.exitDrop_view_stmt(self)




    def drop_view_stmt(self):

        localctx = SQLiteParser.Drop_view_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_drop_view_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 614
            self.match(SQLiteParser.K_DROP)
            self.state = 615
            self.match(SQLiteParser.K_VIEW)
            self.state = 618
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 616
                self.match(SQLiteParser.K_IF)
                self.state = 617
                self.match(SQLiteParser.K_EXISTS)


            self.state = 623
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.state = 620
                self.database_name()
                self.state = 621
                self.match(SQLiteParser.DOT)


            self.state = 625
            self.view_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Factored_select_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def select_core(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Select_coreContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Select_coreContext,i)


        def K_WITH(self):
            return self.getToken(SQLiteParser.K_WITH, 0)

        def common_table_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Common_table_expressionContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Common_table_expressionContext,i)


        def compound_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Compound_operatorContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Compound_operatorContext,i)


        def K_ORDER(self):
            return self.getToken(SQLiteParser.K_ORDER, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def ordering_term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i)


        def K_LIMIT(self):
            return self.getToken(SQLiteParser.K_LIMIT, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def K_RECURSIVE(self):
            return self.getToken(SQLiteParser.K_RECURSIVE, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_OFFSET(self):
            return self.getToken(SQLiteParser.K_OFFSET, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_factored_select_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFactored_select_stmt" ):
                listener.enterFactored_select_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFactored_select_stmt" ):
                listener.exitFactored_select_stmt(self)




    def factored_select_stmt(self):

        localctx = SQLiteParser.Factored_select_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_factored_select_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 639
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WITH:
                self.state = 627
                self.match(SQLiteParser.K_WITH)
                self.state = 629
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
                if la_ == 1:
                    self.state = 628
                    self.match(SQLiteParser.K_RECURSIVE)


                self.state = 631
                self.common_table_expression()
                self.state = 636
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 632
                    self.match(SQLiteParser.COMMA)
                    self.state = 633
                    self.common_table_expression()
                    self.state = 638
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 641
            self.select_core()
            self.state = 647
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.K_EXCEPT or _la==SQLiteParser.K_INTERSECT or _la==SQLiteParser.K_UNION:
                self.state = 642
                self.compound_operator()
                self.state = 643
                self.select_core()
                self.state = 649
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 660
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_ORDER:
                self.state = 650
                self.match(SQLiteParser.K_ORDER)
                self.state = 651
                self.match(SQLiteParser.K_BY)
                self.state = 652
                self.ordering_term()
                self.state = 657
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 653
                    self.match(SQLiteParser.COMMA)
                    self.state = 654
                    self.ordering_term()
                    self.state = 659
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 668
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_LIMIT:
                self.state = 662
                self.match(SQLiteParser.K_LIMIT)
                self.state = 663
                self.expr(0)
                self.state = 666
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET:
                    self.state = 664
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 665
                    self.expr(0)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Insert_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_INTO(self):
            return self.getToken(SQLiteParser.K_INTO, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def K_INSERT(self):
            return self.getToken(SQLiteParser.K_INSERT, 0)

        def K_REPLACE(self):
            return self.getToken(SQLiteParser.K_REPLACE, 0)

        def K_OR(self):
            return self.getToken(SQLiteParser.K_OR, 0)

        def K_ROLLBACK(self):
            return self.getToken(SQLiteParser.K_ROLLBACK, 0)

        def K_ABORT(self):
            return self.getToken(SQLiteParser.K_ABORT, 0)

        def K_FAIL(self):
            return self.getToken(SQLiteParser.K_FAIL, 0)

        def K_IGNORE(self):
            return self.getToken(SQLiteParser.K_IGNORE, 0)

        def K_VALUES(self):
            return self.getToken(SQLiteParser.K_VALUES, 0)

        def OPEN_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.OPEN_PAR)
            else:
                return self.getToken(SQLiteParser.OPEN_PAR, i)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def CLOSE_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.CLOSE_PAR)
            else:
                return self.getToken(SQLiteParser.CLOSE_PAR, i)

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def K_DEFAULT(self):
            return self.getToken(SQLiteParser.K_DEFAULT, 0)

        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_insert_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInsert_stmt" ):
                listener.enterInsert_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInsert_stmt" ):
                listener.exitInsert_stmt(self)




    def insert_stmt(self):

        localctx = SQLiteParser.Insert_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_insert_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 671
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WITH:
                self.state = 670
                self.with_clause()


            self.state = 690
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,86,self._ctx)
            if la_ == 1:
                self.state = 673
                self.match(SQLiteParser.K_INSERT)
                pass

            elif la_ == 2:
                self.state = 674
                self.match(SQLiteParser.K_REPLACE)
                pass

            elif la_ == 3:
                self.state = 675
                self.match(SQLiteParser.K_INSERT)
                self.state = 676
                self.match(SQLiteParser.K_OR)
                self.state = 677
                self.match(SQLiteParser.K_REPLACE)
                pass

            elif la_ == 4:
                self.state = 678
                self.match(SQLiteParser.K_INSERT)
                self.state = 679
                self.match(SQLiteParser.K_OR)
                self.state = 680
                self.match(SQLiteParser.K_ROLLBACK)
                pass

            elif la_ == 5:
                self.state = 681
                self.match(SQLiteParser.K_INSERT)
                self.state = 682
                self.match(SQLiteParser.K_OR)
                self.state = 683
                self.match(SQLiteParser.K_ABORT)
                pass

            elif la_ == 6:
                self.state = 684
                self.match(SQLiteParser.K_INSERT)
                self.state = 685
                self.match(SQLiteParser.K_OR)
                self.state = 686
                self.match(SQLiteParser.K_FAIL)
                pass

            elif la_ == 7:
                self.state = 687
                self.match(SQLiteParser.K_INSERT)
                self.state = 688
                self.match(SQLiteParser.K_OR)
                self.state = 689
                self.match(SQLiteParser.K_IGNORE)
                pass


            self.state = 692
            self.match(SQLiteParser.K_INTO)
            self.state = 696
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.state = 693
                self.database_name()
                self.state = 694
                self.match(SQLiteParser.DOT)


            self.state = 698
            self.table_name()
            self.state = 710
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 699
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 700
                self.column_name()
                self.state = 705
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 701
                    self.match(SQLiteParser.COMMA)
                    self.state = 702
                    self.column_name()
                    self.state = 707
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 708
                self.match(SQLiteParser.CLOSE_PAR)


            self.state = 743
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,93,self._ctx)
            if la_ == 1:
                self.state = 712
                self.match(SQLiteParser.K_VALUES)
                self.state = 713
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 714
                self.expr(0)
                self.state = 719
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 715
                    self.match(SQLiteParser.COMMA)
                    self.state = 716
                    self.expr(0)
                    self.state = 721
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 722
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 737
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 723
                    self.match(SQLiteParser.COMMA)
                    self.state = 724
                    self.match(SQLiteParser.OPEN_PAR)
                    self.state = 725
                    self.expr(0)
                    self.state = 730
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 726
                        self.match(SQLiteParser.COMMA)
                        self.state = 727
                        self.expr(0)
                        self.state = 732
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 733
                    self.match(SQLiteParser.CLOSE_PAR)
                    self.state = 739
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass

            elif la_ == 2:
                self.state = 740
                self.select_stmt()
                pass

            elif la_ == 3:
                self.state = 741
                self.match(SQLiteParser.K_DEFAULT)
                self.state = 742
                self.match(SQLiteParser.K_VALUES)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pragma_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_PRAGMA(self):
            return self.getToken(SQLiteParser.K_PRAGMA, 0)

        def pragma_name(self):
            return self.getTypedRuleContext(SQLiteParser.Pragma_nameContext,0)


        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def ASSIGN(self):
            return self.getToken(SQLiteParser.ASSIGN, 0)

        def pragma_value(self):
            return self.getTypedRuleContext(SQLiteParser.Pragma_valueContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_pragma_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPragma_stmt" ):
                listener.enterPragma_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPragma_stmt" ):
                listener.exitPragma_stmt(self)




    def pragma_stmt(self):

        localctx = SQLiteParser.Pragma_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_pragma_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 745
            self.match(SQLiteParser.K_PRAGMA)
            self.state = 749
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
            if la_ == 1:
                self.state = 746
                self.database_name()
                self.state = 747
                self.match(SQLiteParser.DOT)


            self.state = 751
            self.pragma_name()
            self.state = 758
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.ASSIGN]:
                self.state = 752
                self.match(SQLiteParser.ASSIGN)
                self.state = 753
                self.pragma_value()
                pass
            elif token in [SQLiteParser.OPEN_PAR]:
                self.state = 754
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 755
                self.pragma_value()
                self.state = 756
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.K_ALTER, SQLiteParser.K_ANALYZE, SQLiteParser.K_ATTACH, SQLiteParser.K_BEGIN, SQLiteParser.K_COMMIT, SQLiteParser.K_CREATE, SQLiteParser.K_DELETE, SQLiteParser.K_DETACH, SQLiteParser.K_DROP, SQLiteParser.K_END, SQLiteParser.K_EXPLAIN, SQLiteParser.K_INSERT, SQLiteParser.K_PRAGMA, SQLiteParser.K_REINDEX, SQLiteParser.K_RELEASE, SQLiteParser.K_REPLACE, SQLiteParser.K_ROLLBACK, SQLiteParser.K_SAVEPOINT, SQLiteParser.K_SELECT, SQLiteParser.K_UPDATE, SQLiteParser.K_VACUUM, SQLiteParser.K_VALUES, SQLiteParser.K_WITH, SQLiteParser.UNEXPECTED_CHAR]:
                pass
            else:
                pass
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Reindex_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_REINDEX(self):
            return self.getToken(SQLiteParser.K_REINDEX, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0)


        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_reindex_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterReindex_stmt" ):
                listener.enterReindex_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitReindex_stmt" ):
                listener.exitReindex_stmt(self)




    def reindex_stmt(self):

        localctx = SQLiteParser.Reindex_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_reindex_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 760
            self.match(SQLiteParser.K_REINDEX)
            self.state = 771
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,98,self._ctx)
            if la_ == 1:
                self.state = 761
                self.collation_name()

            elif la_ == 2:
                self.state = 765
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,96,self._ctx)
                if la_ == 1:
                    self.state = 762
                    self.database_name()
                    self.state = 763
                    self.match(SQLiteParser.DOT)


                self.state = 769
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
                if la_ == 1:
                    self.state = 767
                    self.table_name()
                    pass

                elif la_ == 2:
                    self.state = 768
                    self.index_name()
                    pass




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Release_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_RELEASE(self):
            return self.getToken(SQLiteParser.K_RELEASE, 0)

        def savepoint_name(self):
            return self.getTypedRuleContext(SQLiteParser.Savepoint_nameContext,0)


        def K_SAVEPOINT(self):
            return self.getToken(SQLiteParser.K_SAVEPOINT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_release_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRelease_stmt" ):
                listener.enterRelease_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRelease_stmt" ):
                listener.exitRelease_stmt(self)




    def release_stmt(self):

        localctx = SQLiteParser.Release_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_release_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 773
            self.match(SQLiteParser.K_RELEASE)
            self.state = 775
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,99,self._ctx)
            if la_ == 1:
                self.state = 774
                self.match(SQLiteParser.K_SAVEPOINT)


            self.state = 777
            self.savepoint_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Rollback_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_ROLLBACK(self):
            return self.getToken(SQLiteParser.K_ROLLBACK, 0)

        def K_TRANSACTION(self):
            return self.getToken(SQLiteParser.K_TRANSACTION, 0)

        def K_TO(self):
            return self.getToken(SQLiteParser.K_TO, 0)

        def savepoint_name(self):
            return self.getTypedRuleContext(SQLiteParser.Savepoint_nameContext,0)


        def transaction_name(self):
            return self.getTypedRuleContext(SQLiteParser.Transaction_nameContext,0)


        def K_SAVEPOINT(self):
            return self.getToken(SQLiteParser.K_SAVEPOINT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_rollback_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRollback_stmt" ):
                listener.enterRollback_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRollback_stmt" ):
                listener.exitRollback_stmt(self)




    def rollback_stmt(self):

        localctx = SQLiteParser.Rollback_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_rollback_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 779
            self.match(SQLiteParser.K_ROLLBACK)
            self.state = 784
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_TRANSACTION:
                self.state = 780
                self.match(SQLiteParser.K_TRANSACTION)
                self.state = 782
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,100,self._ctx)
                if la_ == 1:
                    self.state = 781
                    self.transaction_name()




            self.state = 791
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_TO:
                self.state = 786
                self.match(SQLiteParser.K_TO)
                self.state = 788
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,102,self._ctx)
                if la_ == 1:
                    self.state = 787
                    self.match(SQLiteParser.K_SAVEPOINT)


                self.state = 790
                self.savepoint_name()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Savepoint_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_SAVEPOINT(self):
            return self.getToken(SQLiteParser.K_SAVEPOINT, 0)

        def savepoint_name(self):
            return self.getTypedRuleContext(SQLiteParser.Savepoint_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_savepoint_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSavepoint_stmt" ):
                listener.enterSavepoint_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSavepoint_stmt" ):
                listener.exitSavepoint_stmt(self)




    def savepoint_stmt(self):

        localctx = SQLiteParser.Savepoint_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_savepoint_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 793
            self.match(SQLiteParser.K_SAVEPOINT)
            self.state = 794
            self.savepoint_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Simple_select_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def select_core(self):
            return self.getTypedRuleContext(SQLiteParser.Select_coreContext,0)


        def K_WITH(self):
            return self.getToken(SQLiteParser.K_WITH, 0)

        def common_table_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Common_table_expressionContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Common_table_expressionContext,i)


        def K_ORDER(self):
            return self.getToken(SQLiteParser.K_ORDER, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def ordering_term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i)


        def K_LIMIT(self):
            return self.getToken(SQLiteParser.K_LIMIT, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def K_RECURSIVE(self):
            return self.getToken(SQLiteParser.K_RECURSIVE, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_OFFSET(self):
            return self.getToken(SQLiteParser.K_OFFSET, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_simple_select_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSimple_select_stmt" ):
                listener.enterSimple_select_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSimple_select_stmt" ):
                listener.exitSimple_select_stmt(self)




    def simple_select_stmt(self):

        localctx = SQLiteParser.Simple_select_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_simple_select_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 808
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WITH:
                self.state = 796
                self.match(SQLiteParser.K_WITH)
                self.state = 798
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
                if la_ == 1:
                    self.state = 797
                    self.match(SQLiteParser.K_RECURSIVE)


                self.state = 800
                self.common_table_expression()
                self.state = 805
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 801
                    self.match(SQLiteParser.COMMA)
                    self.state = 802
                    self.common_table_expression()
                    self.state = 807
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 810
            self.select_core()
            self.state = 821
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_ORDER:
                self.state = 811
                self.match(SQLiteParser.K_ORDER)
                self.state = 812
                self.match(SQLiteParser.K_BY)
                self.state = 813
                self.ordering_term()
                self.state = 818
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 814
                    self.match(SQLiteParser.COMMA)
                    self.state = 815
                    self.ordering_term()
                    self.state = 820
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 829
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_LIMIT:
                self.state = 823
                self.match(SQLiteParser.K_LIMIT)
                self.state = 824
                self.expr(0)
                self.state = 827
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET:
                    self.state = 825
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 826
                    self.expr(0)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Select_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def select_or_values(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Select_or_valuesContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Select_or_valuesContext,i)


        def K_WITH(self):
            return self.getToken(SQLiteParser.K_WITH, 0)

        def common_table_expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Common_table_expressionContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Common_table_expressionContext,i)


        def compound_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Compound_operatorContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Compound_operatorContext,i)


        def K_ORDER(self):
            return self.getToken(SQLiteParser.K_ORDER, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def ordering_term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i)


        def K_LIMIT(self):
            return self.getToken(SQLiteParser.K_LIMIT, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def K_RECURSIVE(self):
            return self.getToken(SQLiteParser.K_RECURSIVE, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_OFFSET(self):
            return self.getToken(SQLiteParser.K_OFFSET, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_select_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelect_stmt" ):
                listener.enterSelect_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelect_stmt" ):
                listener.exitSelect_stmt(self)




    def select_stmt(self):

        localctx = SQLiteParser.Select_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_select_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 843
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WITH:
                self.state = 831
                self.match(SQLiteParser.K_WITH)
                self.state = 833
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
                if la_ == 1:
                    self.state = 832
                    self.match(SQLiteParser.K_RECURSIVE)


                self.state = 835
                self.common_table_expression()
                self.state = 840
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 836
                    self.match(SQLiteParser.COMMA)
                    self.state = 837
                    self.common_table_expression()
                    self.state = 842
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 845
            self.select_or_values()
            self.state = 851
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.K_EXCEPT or _la==SQLiteParser.K_INTERSECT or _la==SQLiteParser.K_UNION:
                self.state = 846
                self.compound_operator()
                self.state = 847
                self.select_or_values()
                self.state = 853
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 864
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_ORDER:
                self.state = 854
                self.match(SQLiteParser.K_ORDER)
                self.state = 855
                self.match(SQLiteParser.K_BY)
                self.state = 856
                self.ordering_term()
                self.state = 861
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 857
                    self.match(SQLiteParser.COMMA)
                    self.state = 858
                    self.ordering_term()
                    self.state = 863
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 872
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_LIMIT:
                self.state = 866
                self.match(SQLiteParser.K_LIMIT)
                self.state = 867
                self.expr(0)
                self.state = 870
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET:
                    self.state = 868
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 869
                    self.expr(0)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Select_or_valuesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_SELECT(self):
            return self.getToken(SQLiteParser.K_SELECT, 0)

        def result_column(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Result_columnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Result_columnContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_FROM(self):
            return self.getToken(SQLiteParser.K_FROM, 0)

        def K_WHERE(self):
            return self.getToken(SQLiteParser.K_WHERE, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def K_GROUP(self):
            return self.getToken(SQLiteParser.K_GROUP, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def K_DISTINCT(self):
            return self.getToken(SQLiteParser.K_DISTINCT, 0)

        def K_ALL(self):
            return self.getToken(SQLiteParser.K_ALL, 0)

        def table_or_subquery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i)


        def join_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Join_clauseContext,0)


        def K_HAVING(self):
            return self.getToken(SQLiteParser.K_HAVING, 0)

        def K_VALUES(self):
            return self.getToken(SQLiteParser.K_VALUES, 0)

        def OPEN_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.OPEN_PAR)
            else:
                return self.getToken(SQLiteParser.OPEN_PAR, i)

        def CLOSE_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.CLOSE_PAR)
            else:
                return self.getToken(SQLiteParser.CLOSE_PAR, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_select_or_values

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelect_or_values" ):
                listener.enterSelect_or_values(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelect_or_values" ):
                listener.exitSelect_or_values(self)




    def select_or_values(self):

        localctx = SQLiteParser.Select_or_valuesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_select_or_values)
        self._la = 0 # Token type
        try:
            self.state = 948
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_SELECT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 874
                self.match(SQLiteParser.K_SELECT)
                self.state = 876
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
                if la_ == 1:
                    self.state = 875
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.K_ALL or _la==SQLiteParser.K_DISTINCT):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 878
                self.result_column()
                self.state = 883
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 879
                    self.match(SQLiteParser.COMMA)
                    self.state = 880
                    self.result_column()
                    self.state = 885
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 898
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_FROM:
                    self.state = 886
                    self.match(SQLiteParser.K_FROM)
                    self.state = 896
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
                    if la_ == 1:
                        self.state = 887
                        self.table_or_subquery()
                        self.state = 892
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==SQLiteParser.COMMA:
                            self.state = 888
                            self.match(SQLiteParser.COMMA)
                            self.state = 889
                            self.table_or_subquery()
                            self.state = 894
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        pass

                    elif la_ == 2:
                        self.state = 895
                        self.join_clause()
                        pass




                self.state = 902
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_WHERE:
                    self.state = 900
                    self.match(SQLiteParser.K_WHERE)
                    self.state = 901
                    self.expr(0)


                self.state = 918
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_GROUP:
                    self.state = 904
                    self.match(SQLiteParser.K_GROUP)
                    self.state = 905
                    self.match(SQLiteParser.K_BY)
                    self.state = 906
                    self.expr(0)
                    self.state = 911
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 907
                        self.match(SQLiteParser.COMMA)
                        self.state = 908
                        self.expr(0)
                        self.state = 913
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 916
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.K_HAVING:
                        self.state = 914
                        self.match(SQLiteParser.K_HAVING)
                        self.state = 915
                        self.expr(0)




                pass
            elif token in [SQLiteParser.K_VALUES]:
                self.enterOuterAlt(localctx, 2)
                self.state = 920
                self.match(SQLiteParser.K_VALUES)
                self.state = 921
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 922
                self.expr(0)
                self.state = 927
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 923
                    self.match(SQLiteParser.COMMA)
                    self.state = 924
                    self.expr(0)
                    self.state = 929
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 930
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 945
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 931
                    self.match(SQLiteParser.COMMA)
                    self.state = 932
                    self.match(SQLiteParser.OPEN_PAR)
                    self.state = 933
                    self.expr(0)
                    self.state = 938
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 934
                        self.match(SQLiteParser.COMMA)
                        self.state = 935
                        self.expr(0)
                        self.state = 940
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 941
                    self.match(SQLiteParser.CLOSE_PAR)
                    self.state = 947
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Update_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_UPDATE(self):
            return self.getToken(SQLiteParser.K_UPDATE, 0)

        def qualified_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0)


        def K_SET(self):
            return self.getToken(SQLiteParser.K_SET, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def ASSIGN(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.ASSIGN)
            else:
                return self.getToken(SQLiteParser.ASSIGN, i)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def K_OR(self):
            return self.getToken(SQLiteParser.K_OR, 0)

        def K_ROLLBACK(self):
            return self.getToken(SQLiteParser.K_ROLLBACK, 0)

        def K_ABORT(self):
            return self.getToken(SQLiteParser.K_ABORT, 0)

        def K_REPLACE(self):
            return self.getToken(SQLiteParser.K_REPLACE, 0)

        def K_FAIL(self):
            return self.getToken(SQLiteParser.K_FAIL, 0)

        def K_IGNORE(self):
            return self.getToken(SQLiteParser.K_IGNORE, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_WHERE(self):
            return self.getToken(SQLiteParser.K_WHERE, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_update_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUpdate_stmt" ):
                listener.enterUpdate_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUpdate_stmt" ):
                listener.exitUpdate_stmt(self)




    def update_stmt(self):

        localctx = SQLiteParser.Update_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_update_stmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 951
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WITH:
                self.state = 950
                self.with_clause()


            self.state = 953
            self.match(SQLiteParser.K_UPDATE)
            self.state = 964
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,133,self._ctx)
            if la_ == 1:
                self.state = 954
                self.match(SQLiteParser.K_OR)
                self.state = 955
                self.match(SQLiteParser.K_ROLLBACK)

            elif la_ == 2:
                self.state = 956
                self.match(SQLiteParser.K_OR)
                self.state = 957
                self.match(SQLiteParser.K_ABORT)

            elif la_ == 3:
                self.state = 958
                self.match(SQLiteParser.K_OR)
                self.state = 959
                self.match(SQLiteParser.K_REPLACE)

            elif la_ == 4:
                self.state = 960
                self.match(SQLiteParser.K_OR)
                self.state = 961
                self.match(SQLiteParser.K_FAIL)

            elif la_ == 5:
                self.state = 962
                self.match(SQLiteParser.K_OR)
                self.state = 963
                self.match(SQLiteParser.K_IGNORE)


            self.state = 966
            self.qualified_table_name()
            self.state = 967
            self.match(SQLiteParser.K_SET)
            self.state = 968
            self.column_name()
            self.state = 969
            self.match(SQLiteParser.ASSIGN)
            self.state = 970
            self.expr(0)
            self.state = 978
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 971
                self.match(SQLiteParser.COMMA)
                self.state = 972
                self.column_name()
                self.state = 973
                self.match(SQLiteParser.ASSIGN)
                self.state = 974
                self.expr(0)
                self.state = 980
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 983
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WHERE:
                self.state = 981
                self.match(SQLiteParser.K_WHERE)
                self.state = 982
                self.expr(0)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Update_stmt_limitedContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_UPDATE(self):
            return self.getToken(SQLiteParser.K_UPDATE, 0)

        def qualified_table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Qualified_table_nameContext,0)


        def K_SET(self):
            return self.getToken(SQLiteParser.K_SET, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def ASSIGN(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.ASSIGN)
            else:
                return self.getToken(SQLiteParser.ASSIGN, i)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def with_clause(self):
            return self.getTypedRuleContext(SQLiteParser.With_clauseContext,0)


        def K_OR(self):
            return self.getToken(SQLiteParser.K_OR, 0)

        def K_ROLLBACK(self):
            return self.getToken(SQLiteParser.K_ROLLBACK, 0)

        def K_ABORT(self):
            return self.getToken(SQLiteParser.K_ABORT, 0)

        def K_REPLACE(self):
            return self.getToken(SQLiteParser.K_REPLACE, 0)

        def K_FAIL(self):
            return self.getToken(SQLiteParser.K_FAIL, 0)

        def K_IGNORE(self):
            return self.getToken(SQLiteParser.K_IGNORE, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_WHERE(self):
            return self.getToken(SQLiteParser.K_WHERE, 0)

        def K_LIMIT(self):
            return self.getToken(SQLiteParser.K_LIMIT, 0)

        def K_ORDER(self):
            return self.getToken(SQLiteParser.K_ORDER, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def ordering_term(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Ordering_termContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Ordering_termContext,i)


        def K_OFFSET(self):
            return self.getToken(SQLiteParser.K_OFFSET, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_update_stmt_limited

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUpdate_stmt_limited" ):
                listener.enterUpdate_stmt_limited(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUpdate_stmt_limited" ):
                listener.exitUpdate_stmt_limited(self)




    def update_stmt_limited(self):

        localctx = SQLiteParser.Update_stmt_limitedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_update_stmt_limited)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 986
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WITH:
                self.state = 985
                self.with_clause()


            self.state = 988
            self.match(SQLiteParser.K_UPDATE)
            self.state = 999
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,137,self._ctx)
            if la_ == 1:
                self.state = 989
                self.match(SQLiteParser.K_OR)
                self.state = 990
                self.match(SQLiteParser.K_ROLLBACK)

            elif la_ == 2:
                self.state = 991
                self.match(SQLiteParser.K_OR)
                self.state = 992
                self.match(SQLiteParser.K_ABORT)

            elif la_ == 3:
                self.state = 993
                self.match(SQLiteParser.K_OR)
                self.state = 994
                self.match(SQLiteParser.K_REPLACE)

            elif la_ == 4:
                self.state = 995
                self.match(SQLiteParser.K_OR)
                self.state = 996
                self.match(SQLiteParser.K_FAIL)

            elif la_ == 5:
                self.state = 997
                self.match(SQLiteParser.K_OR)
                self.state = 998
                self.match(SQLiteParser.K_IGNORE)


            self.state = 1001
            self.qualified_table_name()
            self.state = 1002
            self.match(SQLiteParser.K_SET)
            self.state = 1003
            self.column_name()
            self.state = 1004
            self.match(SQLiteParser.ASSIGN)
            self.state = 1005
            self.expr(0)
            self.state = 1013
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 1006
                self.match(SQLiteParser.COMMA)
                self.state = 1007
                self.column_name()
                self.state = 1008
                self.match(SQLiteParser.ASSIGN)
                self.state = 1009
                self.expr(0)
                self.state = 1015
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1018
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_WHERE:
                self.state = 1016
                self.match(SQLiteParser.K_WHERE)
                self.state = 1017
                self.expr(0)


            self.state = 1038
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_LIMIT or _la==SQLiteParser.K_ORDER:
                self.state = 1030
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_ORDER:
                    self.state = 1020
                    self.match(SQLiteParser.K_ORDER)
                    self.state = 1021
                    self.match(SQLiteParser.K_BY)
                    self.state = 1022
                    self.ordering_term()
                    self.state = 1027
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1023
                        self.match(SQLiteParser.COMMA)
                        self.state = 1024
                        self.ordering_term()
                        self.state = 1029
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 1032
                self.match(SQLiteParser.K_LIMIT)
                self.state = 1033
                self.expr(0)
                self.state = 1036
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET:
                    self.state = 1034
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.COMMA or _la==SQLiteParser.K_OFFSET):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1035
                    self.expr(0)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Vacuum_stmtContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_VACUUM(self):
            return self.getToken(SQLiteParser.K_VACUUM, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_vacuum_stmt

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVacuum_stmt" ):
                listener.enterVacuum_stmt(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVacuum_stmt" ):
                listener.exitVacuum_stmt(self)




    def vacuum_stmt(self):

        localctx = SQLiteParser.Vacuum_stmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_vacuum_stmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1040
            self.match(SQLiteParser.K_VACUUM)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Column_defContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def column_name(self):
            return self.getTypedRuleContext(SQLiteParser.Column_nameContext,0)


        def type_name(self):
            return self.getTypedRuleContext(SQLiteParser.Type_nameContext,0)


        def column_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_constraintContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_constraintContext,i)


        def getRuleIndex(self):
            return SQLiteParser.RULE_column_def

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterColumn_def" ):
                listener.enterColumn_def(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitColumn_def" ):
                listener.exitColumn_def(self)




    def column_def(self):

        localctx = SQLiteParser.Column_defContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_column_def)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1042
            self.column_name()
            self.state = 1044
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,144,self._ctx)
            if la_ == 1:
                self.state = 1043
                self.type_name()


            self.state = 1049
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.K_CHECK) | (1 << SQLiteParser.K_COLLATE) | (1 << SQLiteParser.K_CONSTRAINT) | (1 << SQLiteParser.K_DEFAULT))) != 0) or ((((_la - 102)) & ~0x3f) == 0 and ((1 << (_la - 102)) & ((1 << (SQLiteParser.K_NOT - 102)) | (1 << (SQLiteParser.K_NULL - 102)) | (1 << (SQLiteParser.K_PRIMARY - 102)) | (1 << (SQLiteParser.K_REFERENCES - 102)) | (1 << (SQLiteParser.K_UNIQUE - 102)))) != 0):
                self.state = 1046
                self.column_constraint()
                self.state = 1051
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Type_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.NameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.NameContext,i)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def signed_number(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Signed_numberContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def COMMA(self):
            return self.getToken(SQLiteParser.COMMA, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_type_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterType_name" ):
                listener.enterType_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitType_name" ):
                listener.exitType_name(self)




    def type_name(self):

        localctx = SQLiteParser.Type_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_type_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1053 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1052
                    self.name()

                else:
                    raise NoViableAltException(self)
                self.state = 1055 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,146,self._ctx)

            self.state = 1067
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,147,self._ctx)
            if la_ == 1:
                self.state = 1057
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1058
                self.signed_number()
                self.state = 1059
                self.match(SQLiteParser.CLOSE_PAR)

            elif la_ == 2:
                self.state = 1061
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1062
                self.signed_number()
                self.state = 1063
                self.match(SQLiteParser.COMMA)
                self.state = 1064
                self.signed_number()
                self.state = 1065
                self.match(SQLiteParser.CLOSE_PAR)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Column_constraintContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_PRIMARY(self):
            return self.getToken(SQLiteParser.K_PRIMARY, 0)

        def K_KEY(self):
            return self.getToken(SQLiteParser.K_KEY, 0)

        def conflict_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Conflict_clauseContext,0)


        def K_NULL(self):
            return self.getToken(SQLiteParser.K_NULL, 0)

        def K_UNIQUE(self):
            return self.getToken(SQLiteParser.K_UNIQUE, 0)

        def K_CHECK(self):
            return self.getToken(SQLiteParser.K_CHECK, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def K_DEFAULT(self):
            return self.getToken(SQLiteParser.K_DEFAULT, 0)

        def K_COLLATE(self):
            return self.getToken(SQLiteParser.K_COLLATE, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def foreign_key_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Foreign_key_clauseContext,0)


        def K_CONSTRAINT(self):
            return self.getToken(SQLiteParser.K_CONSTRAINT, 0)

        def name(self):
            return self.getTypedRuleContext(SQLiteParser.NameContext,0)


        def signed_number(self):
            return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0)


        def literal_value(self):
            return self.getTypedRuleContext(SQLiteParser.Literal_valueContext,0)


        def K_AUTOINCREMENT(self):
            return self.getToken(SQLiteParser.K_AUTOINCREMENT, 0)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_ASC(self):
            return self.getToken(SQLiteParser.K_ASC, 0)

        def K_DESC(self):
            return self.getToken(SQLiteParser.K_DESC, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_column_constraint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterColumn_constraint" ):
                listener.enterColumn_constraint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitColumn_constraint" ):
                listener.exitColumn_constraint(self)




    def column_constraint(self):

        localctx = SQLiteParser.Column_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_column_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1071
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_CONSTRAINT:
                self.state = 1069
                self.match(SQLiteParser.K_CONSTRAINT)
                self.state = 1070
                self.name()


            self.state = 1106
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_PRIMARY]:
                self.state = 1073
                self.match(SQLiteParser.K_PRIMARY)
                self.state = 1074
                self.match(SQLiteParser.K_KEY)
                self.state = 1076
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_ASC or _la==SQLiteParser.K_DESC:
                    self.state = 1075
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.K_ASC or _la==SQLiteParser.K_DESC):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1078
                self.conflict_clause()
                self.state = 1080
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_AUTOINCREMENT:
                    self.state = 1079
                    self.match(SQLiteParser.K_AUTOINCREMENT)


                pass
            elif token in [SQLiteParser.K_NOT, SQLiteParser.K_NULL]:
                self.state = 1083
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_NOT:
                    self.state = 1082
                    self.match(SQLiteParser.K_NOT)


                self.state = 1085
                self.match(SQLiteParser.K_NULL)
                self.state = 1086
                self.conflict_clause()
                pass
            elif token in [SQLiteParser.K_UNIQUE]:
                self.state = 1087
                self.match(SQLiteParser.K_UNIQUE)
                self.state = 1088
                self.conflict_clause()
                pass
            elif token in [SQLiteParser.K_CHECK]:
                self.state = 1089
                self.match(SQLiteParser.K_CHECK)
                self.state = 1090
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1091
                self.expr(0)
                self.state = 1092
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.K_DEFAULT]:
                self.state = 1094
                self.match(SQLiteParser.K_DEFAULT)
                self.state = 1101
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,152,self._ctx)
                if la_ == 1:
                    self.state = 1095
                    self.signed_number()
                    pass

                elif la_ == 2:
                    self.state = 1096
                    self.literal_value()
                    pass

                elif la_ == 3:
                    self.state = 1097
                    self.match(SQLiteParser.OPEN_PAR)
                    self.state = 1098
                    self.expr(0)
                    self.state = 1099
                    self.match(SQLiteParser.CLOSE_PAR)
                    pass


                pass
            elif token in [SQLiteParser.K_COLLATE]:
                self.state = 1103
                self.match(SQLiteParser.K_COLLATE)
                self.state = 1104
                self.collation_name()
                pass
            elif token in [SQLiteParser.K_REFERENCES]:
                self.state = 1105
                self.foreign_key_clause()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Conflict_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_ON(self):
            return self.getToken(SQLiteParser.K_ON, 0)

        def K_CONFLICT(self):
            return self.getToken(SQLiteParser.K_CONFLICT, 0)

        def K_ROLLBACK(self):
            return self.getToken(SQLiteParser.K_ROLLBACK, 0)

        def K_ABORT(self):
            return self.getToken(SQLiteParser.K_ABORT, 0)

        def K_FAIL(self):
            return self.getToken(SQLiteParser.K_FAIL, 0)

        def K_IGNORE(self):
            return self.getToken(SQLiteParser.K_IGNORE, 0)

        def K_REPLACE(self):
            return self.getToken(SQLiteParser.K_REPLACE, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_conflict_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConflict_clause" ):
                listener.enterConflict_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConflict_clause" ):
                listener.exitConflict_clause(self)




    def conflict_clause(self):

        localctx = SQLiteParser.Conflict_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_conflict_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1111
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_ON:
                self.state = 1108
                self.match(SQLiteParser.K_ON)
                self.state = 1109
                self.match(SQLiteParser.K_CONFLICT)
                self.state = 1110
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.K_ABORT or ((((_la - 72)) & ~0x3f) == 0 and ((1 << (_la - 72)) & ((1 << (SQLiteParser.K_FAIL - 72)) | (1 << (SQLiteParser.K_IGNORE - 72)) | (1 << (SQLiteParser.K_REPLACE - 72)) | (1 << (SQLiteParser.K_ROLLBACK - 72)))) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExprContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def literal_value(self):
            return self.getTypedRuleContext(SQLiteParser.Literal_valueContext,0)


        def BIND_PARAMETER(self):
            return self.getToken(SQLiteParser.BIND_PARAMETER, 0)

        def column_name(self):
            return self.getTypedRuleContext(SQLiteParser.Column_nameContext,0)


        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def DOT(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.DOT)
            else:
                return self.getToken(SQLiteParser.DOT, i)

        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def unary_operator(self):
            return self.getTypedRuleContext(SQLiteParser.Unary_operatorContext,0)


        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def function_name(self):
            return self.getTypedRuleContext(SQLiteParser.Function_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def STAR(self):
            return self.getToken(SQLiteParser.STAR, 0)

        def K_DISTINCT(self):
            return self.getToken(SQLiteParser.K_DISTINCT, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_CAST(self):
            return self.getToken(SQLiteParser.K_CAST, 0)

        def K_AS(self):
            return self.getToken(SQLiteParser.K_AS, 0)

        def type_name(self):
            return self.getTypedRuleContext(SQLiteParser.Type_nameContext,0)


        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_CASE(self):
            return self.getToken(SQLiteParser.K_CASE, 0)

        def K_END(self):
            return self.getToken(SQLiteParser.K_END, 0)

        def K_WHEN(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_WHEN)
            else:
                return self.getToken(SQLiteParser.K_WHEN, i)

        def K_THEN(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_THEN)
            else:
                return self.getToken(SQLiteParser.K_THEN, i)

        def K_ELSE(self):
            return self.getToken(SQLiteParser.K_ELSE, 0)

        def raise_function(self):
            return self.getTypedRuleContext(SQLiteParser.Raise_functionContext,0)


        def PIPE2(self):
            return self.getToken(SQLiteParser.PIPE2, 0)

        def DIV(self):
            return self.getToken(SQLiteParser.DIV, 0)

        def MOD(self):
            return self.getToken(SQLiteParser.MOD, 0)

        def PLUS(self):
            return self.getToken(SQLiteParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(SQLiteParser.MINUS, 0)

        def LT2(self):
            return self.getToken(SQLiteParser.LT2, 0)

        def GT2(self):
            return self.getToken(SQLiteParser.GT2, 0)

        def AMP(self):
            return self.getToken(SQLiteParser.AMP, 0)

        def PIPE(self):
            return self.getToken(SQLiteParser.PIPE, 0)

        def LT(self):
            return self.getToken(SQLiteParser.LT, 0)

        def LT_EQ(self):
            return self.getToken(SQLiteParser.LT_EQ, 0)

        def GT(self):
            return self.getToken(SQLiteParser.GT, 0)

        def GT_EQ(self):
            return self.getToken(SQLiteParser.GT_EQ, 0)

        def ASSIGN(self):
            return self.getToken(SQLiteParser.ASSIGN, 0)

        def EQ(self):
            return self.getToken(SQLiteParser.EQ, 0)

        def NOT_EQ1(self):
            return self.getToken(SQLiteParser.NOT_EQ1, 0)

        def NOT_EQ2(self):
            return self.getToken(SQLiteParser.NOT_EQ2, 0)

        def K_IS(self):
            return self.getToken(SQLiteParser.K_IS, 0)

        def K_IN(self):
            return self.getToken(SQLiteParser.K_IN, 0)

        def K_LIKE(self):
            return self.getToken(SQLiteParser.K_LIKE, 0)

        def K_GLOB(self):
            return self.getToken(SQLiteParser.K_GLOB, 0)

        def K_MATCH(self):
            return self.getToken(SQLiteParser.K_MATCH, 0)

        def K_REGEXP(self):
            return self.getToken(SQLiteParser.K_REGEXP, 0)

        def K_AND(self):
            return self.getToken(SQLiteParser.K_AND, 0)

        def K_OR(self):
            return self.getToken(SQLiteParser.K_OR, 0)

        def K_BETWEEN(self):
            return self.getToken(SQLiteParser.K_BETWEEN, 0)

        def K_COLLATE(self):
            return self.getToken(SQLiteParser.K_COLLATE, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def K_ESCAPE(self):
            return self.getToken(SQLiteParser.K_ESCAPE, 0)

        def K_ISNULL(self):
            return self.getToken(SQLiteParser.K_ISNULL, 0)

        def K_NOTNULL(self):
            return self.getToken(SQLiteParser.K_NOTNULL, 0)

        def K_NULL(self):
            return self.getToken(SQLiteParser.K_NULL, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_expr

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpr" ):
                listener.enterExpr(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpr" ):
                listener.exitExpr(self)



    def expr(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = SQLiteParser.ExprContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 78
        self.enterRecursionRule(localctx, 78, self.RULE_expr, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1189
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
            if la_ == 1:
                self.state = 1114
                self.literal_value()
                pass

            elif la_ == 2:
                self.state = 1115
                self.match(SQLiteParser.BIND_PARAMETER)
                pass

            elif la_ == 3:
                self.state = 1124
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,156,self._ctx)
                if la_ == 1:
                    self.state = 1119
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,155,self._ctx)
                    if la_ == 1:
                        self.state = 1116
                        self.database_name()
                        self.state = 1117
                        self.match(SQLiteParser.DOT)


                    self.state = 1121
                    self.table_name()
                    self.state = 1122
                    self.match(SQLiteParser.DOT)


                self.state = 1126
                self.column_name()
                pass

            elif la_ == 4:
                self.state = 1127
                self.unary_operator()
                self.state = 1128
                self.expr(21)
                pass

            elif la_ == 5:
                self.state = 1130
                self.function_name()
                self.state = 1131
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1144
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.OPEN_PAR, SQLiteParser.PLUS, SQLiteParser.MINUS, SQLiteParser.TILDE, SQLiteParser.K_ABORT, SQLiteParser.K_ACTION, SQLiteParser.K_ADD, SQLiteParser.K_AFTER, SQLiteParser.K_ALL, SQLiteParser.K_ALTER, SQLiteParser.K_ANALYZE, SQLiteParser.K_AND, SQLiteParser.K_AS, SQLiteParser.K_ASC, SQLiteParser.K_ATTACH, SQLiteParser.K_AUTOINCREMENT, SQLiteParser.K_BEFORE, SQLiteParser.K_BEGIN, SQLiteParser.K_BETWEEN, SQLiteParser.K_BY, SQLiteParser.K_CASCADE, SQLiteParser.K_CASE, SQLiteParser.K_CAST, SQLiteParser.K_CHECK, SQLiteParser.K_COLLATE, SQLiteParser.K_COLUMN, SQLiteParser.K_COMMIT, SQLiteParser.K_CONFLICT, SQLiteParser.K_CONSTRAINT, SQLiteParser.K_CREATE, SQLiteParser.K_CROSS, SQLiteParser.K_CURRENT_DATE, SQLiteParser.K_CURRENT_TIME, SQLiteParser.K_CURRENT_TIMESTAMP, SQLiteParser.K_DATABASE, SQLiteParser.K_DEFAULT, SQLiteParser.K_DEFERRABLE, SQLiteParser.K_DEFERRED, SQLiteParser.K_DELETE, SQLiteParser.K_DESC, SQLiteParser.K_DETACH, SQLiteParser.K_DISTINCT, SQLiteParser.K_DROP, SQLiteParser.K_EACH, SQLiteParser.K_ELSE, SQLiteParser.K_END, SQLiteParser.K_ESCAPE, SQLiteParser.K_EXCEPT, SQLiteParser.K_EXCLUSIVE, SQLiteParser.K_EXISTS, SQLiteParser.K_EXPLAIN, SQLiteParser.K_FAIL, SQLiteParser.K_FOR, SQLiteParser.K_FOREIGN, SQLiteParser.K_FROM, SQLiteParser.K_FULL, SQLiteParser.K_GLOB, SQLiteParser.K_GROUP, SQLiteParser.K_HAVING, SQLiteParser.K_IF, SQLiteParser.K_IGNORE, SQLiteParser.K_IMMEDIATE, SQLiteParser.K_IN, SQLiteParser.K_INDEX, SQLiteParser.K_INDEXED, SQLiteParser.K_INITIALLY, SQLiteParser.K_INNER, SQLiteParser.K_INSERT, SQLiteParser.K_INSTEAD, SQLiteParser.K_INTERSECT, SQLiteParser.K_INTO, SQLiteParser.K_IS, SQLiteParser.K_ISNULL, SQLiteParser.K_JOIN, SQLiteParser.K_KEY, SQLiteParser.K_LEFT, SQLiteParser.K_LIKE, SQLiteParser.K_LIMIT, SQLiteParser.K_MATCH, SQLiteParser.K_NATURAL, SQLiteParser.K_NO, SQLiteParser.K_NOT, SQLiteParser.K_NOTNULL, SQLiteParser.K_NULL, SQLiteParser.K_OF, SQLiteParser.K_OFFSET, SQLiteParser.K_ON, SQLiteParser.K_OR, SQLiteParser.K_ORDER, SQLiteParser.K_OUTER, SQLiteParser.K_PLAN, SQLiteParser.K_PRAGMA, SQLiteParser.K_PRIMARY, SQLiteParser.K_QUERY, SQLiteParser.K_RAISE, SQLiteParser.K_RECURSIVE, SQLiteParser.K_REFERENCES, SQLiteParser.K_REGEXP, SQLiteParser.K_REINDEX, SQLiteParser.K_RELEASE, SQLiteParser.K_RENAME, SQLiteParser.K_REPLACE, SQLiteParser.K_RESTRICT, SQLiteParser.K_RIGHT, SQLiteParser.K_ROLLBACK, SQLiteParser.K_ROW, SQLiteParser.K_SAVEPOINT, SQLiteParser.K_SELECT, SQLiteParser.K_SET, SQLiteParser.K_TABLE, SQLiteParser.K_TEMP, SQLiteParser.K_TEMPORARY, SQLiteParser.K_THEN, SQLiteParser.K_TO, SQLiteParser.K_TRANSACTION, SQLiteParser.K_TRIGGER, SQLiteParser.K_UNION, SQLiteParser.K_UNIQUE, SQLiteParser.K_UPDATE, SQLiteParser.K_USING, SQLiteParser.K_VACUUM, SQLiteParser.K_VALUES, SQLiteParser.K_VIEW, SQLiteParser.K_VIRTUAL, SQLiteParser.K_WHEN, SQLiteParser.K_WHERE, SQLiteParser.K_WITH, SQLiteParser.K_WITHOUT, SQLiteParser.IDENTIFIER, SQLiteParser.NUMERIC_LITERAL, SQLiteParser.BIND_PARAMETER, SQLiteParser.STRING_LITERAL, SQLiteParser.BLOB_LITERAL]:
                    self.state = 1133
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,157,self._ctx)
                    if la_ == 1:
                        self.state = 1132
                        self.match(SQLiteParser.K_DISTINCT)


                    self.state = 1135
                    self.expr(0)
                    self.state = 1140
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1136
                        self.match(SQLiteParser.COMMA)
                        self.state = 1137
                        self.expr(0)
                        self.state = 1142
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass
                elif token in [SQLiteParser.STAR]:
                    self.state = 1143
                    self.match(SQLiteParser.STAR)
                    pass
                elif token in [SQLiteParser.CLOSE_PAR]:
                    pass
                else:
                    pass
                self.state = 1146
                self.match(SQLiteParser.CLOSE_PAR)
                pass

            elif la_ == 6:
                self.state = 1148
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1149
                self.expr(0)
                self.state = 1150
                self.match(SQLiteParser.CLOSE_PAR)
                pass

            elif la_ == 7:
                self.state = 1152
                self.match(SQLiteParser.K_CAST)
                self.state = 1153
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1154
                self.expr(0)
                self.state = 1155
                self.match(SQLiteParser.K_AS)
                self.state = 1156
                self.type_name()
                self.state = 1157
                self.match(SQLiteParser.CLOSE_PAR)
                pass

            elif la_ == 8:
                self.state = 1163
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_EXISTS or _la==SQLiteParser.K_NOT:
                    self.state = 1160
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.K_NOT:
                        self.state = 1159
                        self.match(SQLiteParser.K_NOT)


                    self.state = 1162
                    self.match(SQLiteParser.K_EXISTS)


                self.state = 1165
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1166
                self.select_stmt()
                self.state = 1167
                self.match(SQLiteParser.CLOSE_PAR)
                pass

            elif la_ == 9:
                self.state = 1169
                self.match(SQLiteParser.K_CASE)
                self.state = 1171
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,162,self._ctx)
                if la_ == 1:
                    self.state = 1170
                    self.expr(0)


                self.state = 1178 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 1173
                    self.match(SQLiteParser.K_WHEN)
                    self.state = 1174
                    self.expr(0)
                    self.state = 1175
                    self.match(SQLiteParser.K_THEN)
                    self.state = 1176
                    self.expr(0)
                    self.state = 1180 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==SQLiteParser.K_WHEN):
                        break

                self.state = 1184
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_ELSE:
                    self.state = 1182
                    self.match(SQLiteParser.K_ELSE)
                    self.state = 1183
                    self.expr(0)


                self.state = 1186
                self.match(SQLiteParser.K_END)
                pass

            elif la_ == 10:
                self.state = 1188
                self.raise_function()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 1291
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,178,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1289
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,177,self._ctx)
                    if la_ == 1:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1191
                        if not self.precpred(self._ctx, 20):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
                        self.state = 1192
                        self.match(SQLiteParser.PIPE2)
                        self.state = 1193
                        self.expr(21)
                        pass

                    elif la_ == 2:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1194
                        if not self.precpred(self._ctx, 19):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
                        self.state = 1195
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.STAR) | (1 << SQLiteParser.DIV) | (1 << SQLiteParser.MOD))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1196
                        self.expr(20)
                        pass

                    elif la_ == 3:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1197
                        if not self.precpred(self._ctx, 18):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
                        self.state = 1198
                        _la = self._input.LA(1)
                        if not(_la==SQLiteParser.PLUS or _la==SQLiteParser.MINUS):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1199
                        self.expr(19)
                        pass

                    elif la_ == 4:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1200
                        if not self.precpred(self._ctx, 17):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
                        self.state = 1201
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.LT2) | (1 << SQLiteParser.GT2) | (1 << SQLiteParser.AMP) | (1 << SQLiteParser.PIPE))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1202
                        self.expr(18)
                        pass

                    elif la_ == 5:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1203
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 1204
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.LT) | (1 << SQLiteParser.LT_EQ) | (1 << SQLiteParser.GT) | (1 << SQLiteParser.GT_EQ))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1205
                        self.expr(17)
                        pass

                    elif la_ == 6:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1206
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 1219
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,166,self._ctx)
                        if la_ == 1:
                            self.state = 1207
                            self.match(SQLiteParser.ASSIGN)
                            pass

                        elif la_ == 2:
                            self.state = 1208
                            self.match(SQLiteParser.EQ)
                            pass

                        elif la_ == 3:
                            self.state = 1209
                            self.match(SQLiteParser.NOT_EQ1)
                            pass

                        elif la_ == 4:
                            self.state = 1210
                            self.match(SQLiteParser.NOT_EQ2)
                            pass

                        elif la_ == 5:
                            self.state = 1211
                            self.match(SQLiteParser.K_IS)
                            pass

                        elif la_ == 6:
                            self.state = 1212
                            self.match(SQLiteParser.K_IS)
                            self.state = 1213
                            self.match(SQLiteParser.K_NOT)
                            pass

                        elif la_ == 7:
                            self.state = 1214
                            self.match(SQLiteParser.K_IN)
                            pass

                        elif la_ == 8:
                            self.state = 1215
                            self.match(SQLiteParser.K_LIKE)
                            pass

                        elif la_ == 9:
                            self.state = 1216
                            self.match(SQLiteParser.K_GLOB)
                            pass

                        elif la_ == 10:
                            self.state = 1217
                            self.match(SQLiteParser.K_MATCH)
                            pass

                        elif la_ == 11:
                            self.state = 1218
                            self.match(SQLiteParser.K_REGEXP)
                            pass


                        self.state = 1221
                        self.expr(16)
                        pass

                    elif la_ == 7:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1222
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 1223
                        self.match(SQLiteParser.K_AND)
                        self.state = 1224
                        self.expr(15)
                        pass

                    elif la_ == 8:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1225
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 1226
                        self.match(SQLiteParser.K_OR)
                        self.state = 1227
                        self.expr(14)
                        pass

                    elif la_ == 9:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1228
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 1229
                        self.match(SQLiteParser.K_IS)
                        self.state = 1231
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,167,self._ctx)
                        if la_ == 1:
                            self.state = 1230
                            self.match(SQLiteParser.K_NOT)


                        self.state = 1233
                        self.expr(7)
                        pass

                    elif la_ == 10:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1234
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1236
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SQLiteParser.K_NOT:
                            self.state = 1235
                            self.match(SQLiteParser.K_NOT)


                        self.state = 1238
                        self.match(SQLiteParser.K_BETWEEN)
                        self.state = 1239
                        self.expr(0)
                        self.state = 1240
                        self.match(SQLiteParser.K_AND)
                        self.state = 1241
                        self.expr(6)
                        pass

                    elif la_ == 11:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1243
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1244
                        self.match(SQLiteParser.K_COLLATE)
                        self.state = 1245
                        self.collation_name()
                        pass

                    elif la_ == 12:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1246
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1248
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SQLiteParser.K_NOT:
                            self.state = 1247
                            self.match(SQLiteParser.K_NOT)


                        self.state = 1250
                        _la = self._input.LA(1)
                        if not(((((_la - 77)) & ~0x3f) == 0 and ((1 << (_la - 77)) & ((1 << (SQLiteParser.K_GLOB - 77)) | (1 << (SQLiteParser.K_LIKE - 77)) | (1 << (SQLiteParser.K_MATCH - 77)) | (1 << (SQLiteParser.K_REGEXP - 77)))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1251
                        self.expr(0)
                        self.state = 1254
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,170,self._ctx)
                        if la_ == 1:
                            self.state = 1252
                            self.match(SQLiteParser.K_ESCAPE)
                            self.state = 1253
                            self.expr(0)


                        pass

                    elif la_ == 13:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1256
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 1261
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [SQLiteParser.K_ISNULL]:
                            self.state = 1257
                            self.match(SQLiteParser.K_ISNULL)
                            pass
                        elif token in [SQLiteParser.K_NOTNULL]:
                            self.state = 1258
                            self.match(SQLiteParser.K_NOTNULL)
                            pass
                        elif token in [SQLiteParser.K_NOT]:
                            self.state = 1259
                            self.match(SQLiteParser.K_NOT)
                            self.state = 1260
                            self.match(SQLiteParser.K_NULL)
                            pass
                        else:
                            raise NoViableAltException(self)

                        pass

                    elif la_ == 14:
                        localctx = SQLiteParser.ExprContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 1263
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 1265
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==SQLiteParser.K_NOT:
                            self.state = 1264
                            self.match(SQLiteParser.K_NOT)


                        self.state = 1267
                        self.match(SQLiteParser.K_IN)
                        self.state = 1287
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,176,self._ctx)
                        if la_ == 1:
                            self.state = 1268
                            self.match(SQLiteParser.OPEN_PAR)
                            self.state = 1278
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,174,self._ctx)
                            if la_ == 1:
                                self.state = 1269
                                self.select_stmt()

                            elif la_ == 2:
                                self.state = 1270
                                self.expr(0)
                                self.state = 1275
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)
                                while _la==SQLiteParser.COMMA:
                                    self.state = 1271
                                    self.match(SQLiteParser.COMMA)
                                    self.state = 1272
                                    self.expr(0)
                                    self.state = 1277
                                    self._errHandler.sync(self)
                                    _la = self._input.LA(1)



                            self.state = 1280
                            self.match(SQLiteParser.CLOSE_PAR)
                            pass

                        elif la_ == 2:
                            self.state = 1284
                            self._errHandler.sync(self)
                            la_ = self._interp.adaptivePredict(self._input,175,self._ctx)
                            if la_ == 1:
                                self.state = 1281
                                self.database_name()
                                self.state = 1282
                                self.match(SQLiteParser.DOT)


                            self.state = 1286
                            self.table_name()
                            pass


                        pass

             
                self.state = 1293
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,178,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx


    class Foreign_key_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_REFERENCES(self):
            return self.getToken(SQLiteParser.K_REFERENCES, 0)

        def foreign_table(self):
            return self.getTypedRuleContext(SQLiteParser.Foreign_tableContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def K_DEFERRABLE(self):
            return self.getToken(SQLiteParser.K_DEFERRABLE, 0)

        def K_ON(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_ON)
            else:
                return self.getToken(SQLiteParser.K_ON, i)

        def K_MATCH(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_MATCH)
            else:
                return self.getToken(SQLiteParser.K_MATCH, i)

        def name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.NameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.NameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_DELETE(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_DELETE)
            else:
                return self.getToken(SQLiteParser.K_DELETE, i)

        def K_UPDATE(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_UPDATE)
            else:
                return self.getToken(SQLiteParser.K_UPDATE, i)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_INITIALLY(self):
            return self.getToken(SQLiteParser.K_INITIALLY, 0)

        def K_DEFERRED(self):
            return self.getToken(SQLiteParser.K_DEFERRED, 0)

        def K_IMMEDIATE(self):
            return self.getToken(SQLiteParser.K_IMMEDIATE, 0)

        def K_SET(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_SET)
            else:
                return self.getToken(SQLiteParser.K_SET, i)

        def K_NULL(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_NULL)
            else:
                return self.getToken(SQLiteParser.K_NULL, i)

        def K_DEFAULT(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_DEFAULT)
            else:
                return self.getToken(SQLiteParser.K_DEFAULT, i)

        def K_CASCADE(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_CASCADE)
            else:
                return self.getToken(SQLiteParser.K_CASCADE, i)

        def K_RESTRICT(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_RESTRICT)
            else:
                return self.getToken(SQLiteParser.K_RESTRICT, i)

        def K_NO(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_NO)
            else:
                return self.getToken(SQLiteParser.K_NO, i)

        def K_ACTION(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_ACTION)
            else:
                return self.getToken(SQLiteParser.K_ACTION, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_foreign_key_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForeign_key_clause" ):
                listener.enterForeign_key_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForeign_key_clause" ):
                listener.exitForeign_key_clause(self)




    def foreign_key_clause(self):

        localctx = SQLiteParser.Foreign_key_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_foreign_key_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1294
            self.match(SQLiteParser.K_REFERENCES)
            self.state = 1295
            self.foreign_table()
            self.state = 1307
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 1296
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1297
                self.column_name()
                self.state = 1302
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1298
                    self.match(SQLiteParser.COMMA)
                    self.state = 1299
                    self.column_name()
                    self.state = 1304
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1305
                self.match(SQLiteParser.CLOSE_PAR)


            self.state = 1327
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.K_MATCH or _la==SQLiteParser.K_ON:
                self.state = 1323
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.K_ON]:
                    self.state = 1309
                    self.match(SQLiteParser.K_ON)
                    self.state = 1310
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.K_DELETE or _la==SQLiteParser.K_UPDATE):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 1319
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,181,self._ctx)
                    if la_ == 1:
                        self.state = 1311
                        self.match(SQLiteParser.K_SET)
                        self.state = 1312
                        self.match(SQLiteParser.K_NULL)
                        pass

                    elif la_ == 2:
                        self.state = 1313
                        self.match(SQLiteParser.K_SET)
                        self.state = 1314
                        self.match(SQLiteParser.K_DEFAULT)
                        pass

                    elif la_ == 3:
                        self.state = 1315
                        self.match(SQLiteParser.K_CASCADE)
                        pass

                    elif la_ == 4:
                        self.state = 1316
                        self.match(SQLiteParser.K_RESTRICT)
                        pass

                    elif la_ == 5:
                        self.state = 1317
                        self.match(SQLiteParser.K_NO)
                        self.state = 1318
                        self.match(SQLiteParser.K_ACTION)
                        pass


                    pass
                elif token in [SQLiteParser.K_MATCH]:
                    self.state = 1321
                    self.match(SQLiteParser.K_MATCH)
                    self.state = 1322
                    self.name()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1329
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1340
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,186,self._ctx)
            if la_ == 1:
                self.state = 1331
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_NOT:
                    self.state = 1330
                    self.match(SQLiteParser.K_NOT)


                self.state = 1333
                self.match(SQLiteParser.K_DEFERRABLE)
                self.state = 1338
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,185,self._ctx)
                if la_ == 1:
                    self.state = 1334
                    self.match(SQLiteParser.K_INITIALLY)
                    self.state = 1335
                    self.match(SQLiteParser.K_DEFERRED)

                elif la_ == 2:
                    self.state = 1336
                    self.match(SQLiteParser.K_INITIALLY)
                    self.state = 1337
                    self.match(SQLiteParser.K_IMMEDIATE)




        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Raise_functionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_RAISE(self):
            return self.getToken(SQLiteParser.K_RAISE, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def K_IGNORE(self):
            return self.getToken(SQLiteParser.K_IGNORE, 0)

        def COMMA(self):
            return self.getToken(SQLiteParser.COMMA, 0)

        def error_message(self):
            return self.getTypedRuleContext(SQLiteParser.Error_messageContext,0)


        def K_ROLLBACK(self):
            return self.getToken(SQLiteParser.K_ROLLBACK, 0)

        def K_ABORT(self):
            return self.getToken(SQLiteParser.K_ABORT, 0)

        def K_FAIL(self):
            return self.getToken(SQLiteParser.K_FAIL, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_raise_function

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterRaise_function" ):
                listener.enterRaise_function(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitRaise_function" ):
                listener.exitRaise_function(self)




    def raise_function(self):

        localctx = SQLiteParser.Raise_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_raise_function)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1342
            self.match(SQLiteParser.K_RAISE)
            self.state = 1343
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1348
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_IGNORE]:
                self.state = 1344
                self.match(SQLiteParser.K_IGNORE)
                pass
            elif token in [SQLiteParser.K_ABORT, SQLiteParser.K_FAIL, SQLiteParser.K_ROLLBACK]:
                self.state = 1345
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.K_ABORT or _la==SQLiteParser.K_FAIL or _la==SQLiteParser.K_ROLLBACK):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1346
                self.match(SQLiteParser.COMMA)
                self.state = 1347
                self.error_message()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1350
            self.match(SQLiteParser.CLOSE_PAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Indexed_columnContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def column_name(self):
            return self.getTypedRuleContext(SQLiteParser.Column_nameContext,0)


        def K_COLLATE(self):
            return self.getToken(SQLiteParser.K_COLLATE, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def K_ASC(self):
            return self.getToken(SQLiteParser.K_ASC, 0)

        def K_DESC(self):
            return self.getToken(SQLiteParser.K_DESC, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_indexed_column

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIndexed_column" ):
                listener.enterIndexed_column(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIndexed_column" ):
                listener.exitIndexed_column(self)




    def indexed_column(self):

        localctx = SQLiteParser.Indexed_columnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_indexed_column)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1352
            self.column_name()
            self.state = 1355
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_COLLATE:
                self.state = 1353
                self.match(SQLiteParser.K_COLLATE)
                self.state = 1354
                self.collation_name()


            self.state = 1358
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_ASC or _la==SQLiteParser.K_DESC:
                self.state = 1357
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.K_ASC or _la==SQLiteParser.K_DESC):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_constraintContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def indexed_column(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Indexed_columnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Indexed_columnContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def conflict_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Conflict_clauseContext,0)


        def K_CHECK(self):
            return self.getToken(SQLiteParser.K_CHECK, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def K_FOREIGN(self):
            return self.getToken(SQLiteParser.K_FOREIGN, 0)

        def K_KEY(self):
            return self.getToken(SQLiteParser.K_KEY, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def foreign_key_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Foreign_key_clauseContext,0)


        def K_CONSTRAINT(self):
            return self.getToken(SQLiteParser.K_CONSTRAINT, 0)

        def name(self):
            return self.getTypedRuleContext(SQLiteParser.NameContext,0)


        def K_PRIMARY(self):
            return self.getToken(SQLiteParser.K_PRIMARY, 0)

        def K_UNIQUE(self):
            return self.getToken(SQLiteParser.K_UNIQUE, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_table_constraint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTable_constraint" ):
                listener.enterTable_constraint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTable_constraint" ):
                listener.exitTable_constraint(self)




    def table_constraint(self):

        localctx = SQLiteParser.Table_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_table_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1362
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_CONSTRAINT:
                self.state = 1360
                self.match(SQLiteParser.K_CONSTRAINT)
                self.state = 1361
                self.name()


            self.state = 1400
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_PRIMARY, SQLiteParser.K_UNIQUE]:
                self.state = 1367
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.K_PRIMARY]:
                    self.state = 1364
                    self.match(SQLiteParser.K_PRIMARY)
                    self.state = 1365
                    self.match(SQLiteParser.K_KEY)
                    pass
                elif token in [SQLiteParser.K_UNIQUE]:
                    self.state = 1366
                    self.match(SQLiteParser.K_UNIQUE)
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 1369
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1370
                self.indexed_column()
                self.state = 1375
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1371
                    self.match(SQLiteParser.COMMA)
                    self.state = 1372
                    self.indexed_column()
                    self.state = 1377
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1378
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1379
                self.conflict_clause()
                pass
            elif token in [SQLiteParser.K_CHECK]:
                self.state = 1381
                self.match(SQLiteParser.K_CHECK)
                self.state = 1382
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1383
                self.expr(0)
                self.state = 1384
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.K_FOREIGN]:
                self.state = 1386
                self.match(SQLiteParser.K_FOREIGN)
                self.state = 1387
                self.match(SQLiteParser.K_KEY)
                self.state = 1388
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1389
                self.column_name()
                self.state = 1394
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1390
                    self.match(SQLiteParser.COMMA)
                    self.state = 1391
                    self.column_name()
                    self.state = 1396
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1397
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1398
                self.foreign_key_clause()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class With_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_WITH(self):
            return self.getToken(SQLiteParser.K_WITH, 0)

        def cte_table_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Cte_table_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Cte_table_nameContext,i)


        def K_AS(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.K_AS)
            else:
                return self.getToken(SQLiteParser.K_AS, i)

        def OPEN_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.OPEN_PAR)
            else:
                return self.getToken(SQLiteParser.OPEN_PAR, i)

        def select_stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Select_stmtContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,i)


        def CLOSE_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.CLOSE_PAR)
            else:
                return self.getToken(SQLiteParser.CLOSE_PAR, i)

        def K_RECURSIVE(self):
            return self.getToken(SQLiteParser.K_RECURSIVE, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_with_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWith_clause" ):
                listener.enterWith_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWith_clause" ):
                listener.exitWith_clause(self)




    def with_clause(self):

        localctx = SQLiteParser.With_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_with_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1402
            self.match(SQLiteParser.K_WITH)
            self.state = 1404
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,195,self._ctx)
            if la_ == 1:
                self.state = 1403
                self.match(SQLiteParser.K_RECURSIVE)


            self.state = 1406
            self.cte_table_name()
            self.state = 1407
            self.match(SQLiteParser.K_AS)
            self.state = 1408
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1409
            self.select_stmt()
            self.state = 1410
            self.match(SQLiteParser.CLOSE_PAR)
            self.state = 1420
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA:
                self.state = 1411
                self.match(SQLiteParser.COMMA)
                self.state = 1412
                self.cte_table_name()
                self.state = 1413
                self.match(SQLiteParser.K_AS)
                self.state = 1414
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1415
                self.select_stmt()
                self.state = 1416
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1422
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Qualified_table_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def K_INDEXED(self):
            return self.getToken(SQLiteParser.K_INDEXED, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0)


        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_qualified_table_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterQualified_table_name" ):
                listener.enterQualified_table_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitQualified_table_name" ):
                listener.exitQualified_table_name(self)




    def qualified_table_name(self):

        localctx = SQLiteParser.Qualified_table_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_qualified_table_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1426
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,197,self._ctx)
            if la_ == 1:
                self.state = 1423
                self.database_name()
                self.state = 1424
                self.match(SQLiteParser.DOT)


            self.state = 1428
            self.table_name()
            self.state = 1434
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_INDEXED]:
                self.state = 1429
                self.match(SQLiteParser.K_INDEXED)
                self.state = 1430
                self.match(SQLiteParser.K_BY)
                self.state = 1431
                self.index_name()
                pass
            elif token in [SQLiteParser.K_NOT]:
                self.state = 1432
                self.match(SQLiteParser.K_NOT)
                self.state = 1433
                self.match(SQLiteParser.K_INDEXED)
                pass
            elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.K_ALTER, SQLiteParser.K_ANALYZE, SQLiteParser.K_ATTACH, SQLiteParser.K_BEGIN, SQLiteParser.K_COMMIT, SQLiteParser.K_CREATE, SQLiteParser.K_DELETE, SQLiteParser.K_DETACH, SQLiteParser.K_DROP, SQLiteParser.K_END, SQLiteParser.K_EXPLAIN, SQLiteParser.K_INSERT, SQLiteParser.K_LIMIT, SQLiteParser.K_ORDER, SQLiteParser.K_PRAGMA, SQLiteParser.K_REINDEX, SQLiteParser.K_RELEASE, SQLiteParser.K_REPLACE, SQLiteParser.K_ROLLBACK, SQLiteParser.K_SAVEPOINT, SQLiteParser.K_SELECT, SQLiteParser.K_SET, SQLiteParser.K_UPDATE, SQLiteParser.K_VACUUM, SQLiteParser.K_VALUES, SQLiteParser.K_WHERE, SQLiteParser.K_WITH, SQLiteParser.UNEXPECTED_CHAR]:
                pass
            else:
                pass
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ordering_termContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def K_COLLATE(self):
            return self.getToken(SQLiteParser.K_COLLATE, 0)

        def collation_name(self):
            return self.getTypedRuleContext(SQLiteParser.Collation_nameContext,0)


        def K_ASC(self):
            return self.getToken(SQLiteParser.K_ASC, 0)

        def K_DESC(self):
            return self.getToken(SQLiteParser.K_DESC, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_ordering_term

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOrdering_term" ):
                listener.enterOrdering_term(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOrdering_term" ):
                listener.exitOrdering_term(self)




    def ordering_term(self):

        localctx = SQLiteParser.Ordering_termContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_ordering_term)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1436
            self.expr(0)
            self.state = 1439
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_COLLATE:
                self.state = 1437
                self.match(SQLiteParser.K_COLLATE)
                self.state = 1438
                self.collation_name()


            self.state = 1442
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.K_ASC or _la==SQLiteParser.K_DESC:
                self.state = 1441
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.K_ASC or _la==SQLiteParser.K_DESC):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pragma_valueContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def signed_number(self):
            return self.getTypedRuleContext(SQLiteParser.Signed_numberContext,0)


        def name(self):
            return self.getTypedRuleContext(SQLiteParser.NameContext,0)


        def STRING_LITERAL(self):
            return self.getToken(SQLiteParser.STRING_LITERAL, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_pragma_value

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPragma_value" ):
                listener.enterPragma_value(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPragma_value" ):
                listener.exitPragma_value(self)




    def pragma_value(self):

        localctx = SQLiteParser.Pragma_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_pragma_value)
        try:
            self.state = 1447
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,201,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1444
                self.signed_number()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1445
                self.name()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1446
                self.match(SQLiteParser.STRING_LITERAL)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Common_table_expressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def K_AS(self):
            return self.getToken(SQLiteParser.K_AS, 0)

        def OPEN_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.OPEN_PAR)
            else:
                return self.getToken(SQLiteParser.OPEN_PAR, i)

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def CLOSE_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.CLOSE_PAR)
            else:
                return self.getToken(SQLiteParser.CLOSE_PAR, i)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_common_table_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCommon_table_expression" ):
                listener.enterCommon_table_expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCommon_table_expression" ):
                listener.exitCommon_table_expression(self)




    def common_table_expression(self):

        localctx = SQLiteParser.Common_table_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_common_table_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1449
            self.table_name()
            self.state = 1461
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 1450
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1451
                self.column_name()
                self.state = 1456
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1452
                    self.match(SQLiteParser.COMMA)
                    self.state = 1453
                    self.column_name()
                    self.state = 1458
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1459
                self.match(SQLiteParser.CLOSE_PAR)


            self.state = 1463
            self.match(SQLiteParser.K_AS)
            self.state = 1464
            self.match(SQLiteParser.OPEN_PAR)
            self.state = 1465
            self.select_stmt()
            self.state = 1466
            self.match(SQLiteParser.CLOSE_PAR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Result_columnContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STAR(self):
            return self.getToken(SQLiteParser.STAR, 0)

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def column_alias(self):
            return self.getTypedRuleContext(SQLiteParser.Column_aliasContext,0)


        def K_AS(self):
            return self.getToken(SQLiteParser.K_AS, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_result_column

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterResult_column" ):
                listener.enterResult_column(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitResult_column" ):
                listener.exitResult_column(self)




    def result_column(self):

        localctx = SQLiteParser.Result_columnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_result_column)
        self._la = 0 # Token type
        try:
            self.state = 1480
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,206,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1468
                self.match(SQLiteParser.STAR)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1469
                self.table_name()
                self.state = 1470
                self.match(SQLiteParser.DOT)
                self.state = 1471
                self.match(SQLiteParser.STAR)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1473
                self.expr(0)
                self.state = 1478
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_AS or _la==SQLiteParser.IDENTIFIER or _la==SQLiteParser.STRING_LITERAL:
                    self.state = 1475
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.K_AS:
                        self.state = 1474
                        self.match(SQLiteParser.K_AS)


                    self.state = 1477
                    self.column_alias()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_or_subqueryContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def database_name(self):
            return self.getTypedRuleContext(SQLiteParser.Database_nameContext,0)


        def DOT(self):
            return self.getToken(SQLiteParser.DOT, 0)

        def table_alias(self):
            return self.getTypedRuleContext(SQLiteParser.Table_aliasContext,0)


        def K_INDEXED(self):
            return self.getToken(SQLiteParser.K_INDEXED, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def index_name(self):
            return self.getTypedRuleContext(SQLiteParser.Index_nameContext,0)


        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_AS(self):
            return self.getToken(SQLiteParser.K_AS, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def table_or_subquery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i)


        def join_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Join_clauseContext,0)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def select_stmt(self):
            return self.getTypedRuleContext(SQLiteParser.Select_stmtContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_or_subquery

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTable_or_subquery" ):
                listener.enterTable_or_subquery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTable_or_subquery" ):
                listener.exitTable_or_subquery(self)




    def table_or_subquery(self):

        localctx = SQLiteParser.Table_or_subqueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_table_or_subquery)
        self._la = 0 # Token type
        try:
            self.state = 1529
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,217,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1485
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,207,self._ctx)
                if la_ == 1:
                    self.state = 1482
                    self.database_name()
                    self.state = 1483
                    self.match(SQLiteParser.DOT)


                self.state = 1487
                self.table_name()
                self.state = 1492
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,209,self._ctx)
                if la_ == 1:
                    self.state = 1489
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,208,self._ctx)
                    if la_ == 1:
                        self.state = 1488
                        self.match(SQLiteParser.K_AS)


                    self.state = 1491
                    self.table_alias()


                self.state = 1499
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.K_INDEXED]:
                    self.state = 1494
                    self.match(SQLiteParser.K_INDEXED)
                    self.state = 1495
                    self.match(SQLiteParser.K_BY)
                    self.state = 1496
                    self.index_name()
                    pass
                elif token in [SQLiteParser.K_NOT]:
                    self.state = 1497
                    self.match(SQLiteParser.K_NOT)
                    self.state = 1498
                    self.match(SQLiteParser.K_INDEXED)
                    pass
                elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.CLOSE_PAR, SQLiteParser.COMMA, SQLiteParser.K_ALTER, SQLiteParser.K_ANALYZE, SQLiteParser.K_ATTACH, SQLiteParser.K_BEGIN, SQLiteParser.K_COMMIT, SQLiteParser.K_CREATE, SQLiteParser.K_CROSS, SQLiteParser.K_DELETE, SQLiteParser.K_DETACH, SQLiteParser.K_DROP, SQLiteParser.K_END, SQLiteParser.K_EXCEPT, SQLiteParser.K_EXPLAIN, SQLiteParser.K_GROUP, SQLiteParser.K_INNER, SQLiteParser.K_INSERT, SQLiteParser.K_INTERSECT, SQLiteParser.K_JOIN, SQLiteParser.K_LEFT, SQLiteParser.K_LIMIT, SQLiteParser.K_NATURAL, SQLiteParser.K_ON, SQLiteParser.K_ORDER, SQLiteParser.K_PRAGMA, SQLiteParser.K_REINDEX, SQLiteParser.K_RELEASE, SQLiteParser.K_REPLACE, SQLiteParser.K_ROLLBACK, SQLiteParser.K_SAVEPOINT, SQLiteParser.K_SELECT, SQLiteParser.K_UNION, SQLiteParser.K_UPDATE, SQLiteParser.K_USING, SQLiteParser.K_VACUUM, SQLiteParser.K_VALUES, SQLiteParser.K_WHERE, SQLiteParser.K_WITH, SQLiteParser.UNEXPECTED_CHAR]:
                    pass
                else:
                    pass
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1501
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1511
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,212,self._ctx)
                if la_ == 1:
                    self.state = 1502
                    self.table_or_subquery()
                    self.state = 1507
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1503
                        self.match(SQLiteParser.COMMA)
                        self.state = 1504
                        self.table_or_subquery()
                        self.state = 1509
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    pass

                elif la_ == 2:
                    self.state = 1510
                    self.join_clause()
                    pass


                self.state = 1513
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1518
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,214,self._ctx)
                if la_ == 1:
                    self.state = 1515
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,213,self._ctx)
                    if la_ == 1:
                        self.state = 1514
                        self.match(SQLiteParser.K_AS)


                    self.state = 1517
                    self.table_alias()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1520
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1521
                self.select_stmt()
                self.state = 1522
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1527
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,216,self._ctx)
                if la_ == 1:
                    self.state = 1524
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,215,self._ctx)
                    if la_ == 1:
                        self.state = 1523
                        self.match(SQLiteParser.K_AS)


                    self.state = 1526
                    self.table_alias()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Join_clauseContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def table_or_subquery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i)


        def join_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Join_operatorContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Join_operatorContext,i)


        def join_constraint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Join_constraintContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Join_constraintContext,i)


        def getRuleIndex(self):
            return SQLiteParser.RULE_join_clause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJoin_clause" ):
                listener.enterJoin_clause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJoin_clause" ):
                listener.exitJoin_clause(self)




    def join_clause(self):

        localctx = SQLiteParser.Join_clauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_join_clause)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1531
            self.table_or_subquery()
            self.state = 1538
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==SQLiteParser.COMMA or _la==SQLiteParser.K_CROSS or ((((_la - 87)) & ~0x3f) == 0 and ((1 << (_la - 87)) & ((1 << (SQLiteParser.K_INNER - 87)) | (1 << (SQLiteParser.K_JOIN - 87)) | (1 << (SQLiteParser.K_LEFT - 87)) | (1 << (SQLiteParser.K_NATURAL - 87)))) != 0):
                self.state = 1532
                self.join_operator()
                self.state = 1533
                self.table_or_subquery()
                self.state = 1534
                self.join_constraint()
                self.state = 1540
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Join_operatorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def COMMA(self):
            return self.getToken(SQLiteParser.COMMA, 0)

        def K_JOIN(self):
            return self.getToken(SQLiteParser.K_JOIN, 0)

        def K_NATURAL(self):
            return self.getToken(SQLiteParser.K_NATURAL, 0)

        def K_LEFT(self):
            return self.getToken(SQLiteParser.K_LEFT, 0)

        def K_INNER(self):
            return self.getToken(SQLiteParser.K_INNER, 0)

        def K_CROSS(self):
            return self.getToken(SQLiteParser.K_CROSS, 0)

        def K_OUTER(self):
            return self.getToken(SQLiteParser.K_OUTER, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_join_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJoin_operator" ):
                listener.enterJoin_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJoin_operator" ):
                listener.exitJoin_operator(self)




    def join_operator(self):

        localctx = SQLiteParser.Join_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_join_operator)
        self._la = 0 # Token type
        try:
            self.state = 1554
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.COMMA]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1541
                self.match(SQLiteParser.COMMA)
                pass
            elif token in [SQLiteParser.K_CROSS, SQLiteParser.K_INNER, SQLiteParser.K_JOIN, SQLiteParser.K_LEFT, SQLiteParser.K_NATURAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1543
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_NATURAL:
                    self.state = 1542
                    self.match(SQLiteParser.K_NATURAL)


                self.state = 1551
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [SQLiteParser.K_LEFT]:
                    self.state = 1545
                    self.match(SQLiteParser.K_LEFT)
                    self.state = 1547
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.K_OUTER:
                        self.state = 1546
                        self.match(SQLiteParser.K_OUTER)


                    pass
                elif token in [SQLiteParser.K_INNER]:
                    self.state = 1549
                    self.match(SQLiteParser.K_INNER)
                    pass
                elif token in [SQLiteParser.K_CROSS]:
                    self.state = 1550
                    self.match(SQLiteParser.K_CROSS)
                    pass
                elif token in [SQLiteParser.K_JOIN]:
                    pass
                else:
                    pass
                self.state = 1553
                self.match(SQLiteParser.K_JOIN)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Join_constraintContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_ON(self):
            return self.getToken(SQLiteParser.K_ON, 0)

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def K_USING(self):
            return self.getToken(SQLiteParser.K_USING, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_join_constraint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterJoin_constraint" ):
                listener.enterJoin_constraint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitJoin_constraint" ):
                listener.exitJoin_constraint(self)




    def join_constraint(self):

        localctx = SQLiteParser.Join_constraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_join_constraint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1570
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_ON]:
                self.state = 1556
                self.match(SQLiteParser.K_ON)
                self.state = 1557
                self.expr(0)
                pass
            elif token in [SQLiteParser.K_USING]:
                self.state = 1558
                self.match(SQLiteParser.K_USING)
                self.state = 1559
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1560
                self.column_name()
                self.state = 1565
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1561
                    self.match(SQLiteParser.COMMA)
                    self.state = 1562
                    self.column_name()
                    self.state = 1567
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1568
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            elif token in [SQLiteParser.EOF, SQLiteParser.SCOL, SQLiteParser.CLOSE_PAR, SQLiteParser.COMMA, SQLiteParser.K_ALTER, SQLiteParser.K_ANALYZE, SQLiteParser.K_ATTACH, SQLiteParser.K_BEGIN, SQLiteParser.K_COMMIT, SQLiteParser.K_CREATE, SQLiteParser.K_CROSS, SQLiteParser.K_DELETE, SQLiteParser.K_DETACH, SQLiteParser.K_DROP, SQLiteParser.K_END, SQLiteParser.K_EXCEPT, SQLiteParser.K_EXPLAIN, SQLiteParser.K_GROUP, SQLiteParser.K_INNER, SQLiteParser.K_INSERT, SQLiteParser.K_INTERSECT, SQLiteParser.K_JOIN, SQLiteParser.K_LEFT, SQLiteParser.K_LIMIT, SQLiteParser.K_NATURAL, SQLiteParser.K_ORDER, SQLiteParser.K_PRAGMA, SQLiteParser.K_REINDEX, SQLiteParser.K_RELEASE, SQLiteParser.K_REPLACE, SQLiteParser.K_ROLLBACK, SQLiteParser.K_SAVEPOINT, SQLiteParser.K_SELECT, SQLiteParser.K_UNION, SQLiteParser.K_UPDATE, SQLiteParser.K_VACUUM, SQLiteParser.K_VALUES, SQLiteParser.K_WHERE, SQLiteParser.K_WITH, SQLiteParser.UNEXPECTED_CHAR]:
                pass
            else:
                pass
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Select_coreContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_SELECT(self):
            return self.getToken(SQLiteParser.K_SELECT, 0)

        def result_column(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Result_columnContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Result_columnContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def K_FROM(self):
            return self.getToken(SQLiteParser.K_FROM, 0)

        def K_WHERE(self):
            return self.getToken(SQLiteParser.K_WHERE, 0)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.ExprContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.ExprContext,i)


        def K_GROUP(self):
            return self.getToken(SQLiteParser.K_GROUP, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def K_DISTINCT(self):
            return self.getToken(SQLiteParser.K_DISTINCT, 0)

        def K_ALL(self):
            return self.getToken(SQLiteParser.K_ALL, 0)

        def table_or_subquery(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Table_or_subqueryContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Table_or_subqueryContext,i)


        def join_clause(self):
            return self.getTypedRuleContext(SQLiteParser.Join_clauseContext,0)


        def K_HAVING(self):
            return self.getToken(SQLiteParser.K_HAVING, 0)

        def K_VALUES(self):
            return self.getToken(SQLiteParser.K_VALUES, 0)

        def OPEN_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.OPEN_PAR)
            else:
                return self.getToken(SQLiteParser.OPEN_PAR, i)

        def CLOSE_PAR(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.CLOSE_PAR)
            else:
                return self.getToken(SQLiteParser.CLOSE_PAR, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_select_core

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelect_core" ):
                listener.enterSelect_core(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelect_core" ):
                listener.exitSelect_core(self)




    def select_core(self):

        localctx = SQLiteParser.Select_coreContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_select_core)
        self._la = 0 # Token type
        try:
            self.state = 1646
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.K_SELECT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1572
                self.match(SQLiteParser.K_SELECT)
                self.state = 1574
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,225,self._ctx)
                if la_ == 1:
                    self.state = 1573
                    _la = self._input.LA(1)
                    if not(_la==SQLiteParser.K_ALL or _la==SQLiteParser.K_DISTINCT):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                self.state = 1576
                self.result_column()
                self.state = 1581
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1577
                    self.match(SQLiteParser.COMMA)
                    self.state = 1578
                    self.result_column()
                    self.state = 1583
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1596
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_FROM:
                    self.state = 1584
                    self.match(SQLiteParser.K_FROM)
                    self.state = 1594
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,228,self._ctx)
                    if la_ == 1:
                        self.state = 1585
                        self.table_or_subquery()
                        self.state = 1590
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while _la==SQLiteParser.COMMA:
                            self.state = 1586
                            self.match(SQLiteParser.COMMA)
                            self.state = 1587
                            self.table_or_subquery()
                            self.state = 1592
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)

                        pass

                    elif la_ == 2:
                        self.state = 1593
                        self.join_clause()
                        pass




                self.state = 1600
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_WHERE:
                    self.state = 1598
                    self.match(SQLiteParser.K_WHERE)
                    self.state = 1599
                    self.expr(0)


                self.state = 1616
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==SQLiteParser.K_GROUP:
                    self.state = 1602
                    self.match(SQLiteParser.K_GROUP)
                    self.state = 1603
                    self.match(SQLiteParser.K_BY)
                    self.state = 1604
                    self.expr(0)
                    self.state = 1609
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1605
                        self.match(SQLiteParser.COMMA)
                        self.state = 1606
                        self.expr(0)
                        self.state = 1611
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1614
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==SQLiteParser.K_HAVING:
                        self.state = 1612
                        self.match(SQLiteParser.K_HAVING)
                        self.state = 1613
                        self.expr(0)




                pass
            elif token in [SQLiteParser.K_VALUES]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1618
                self.match(SQLiteParser.K_VALUES)
                self.state = 1619
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1620
                self.expr(0)
                self.state = 1625
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1621
                    self.match(SQLiteParser.COMMA)
                    self.state = 1622
                    self.expr(0)
                    self.state = 1627
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1628
                self.match(SQLiteParser.CLOSE_PAR)
                self.state = 1643
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1629
                    self.match(SQLiteParser.COMMA)
                    self.state = 1630
                    self.match(SQLiteParser.OPEN_PAR)
                    self.state = 1631
                    self.expr(0)
                    self.state = 1636
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==SQLiteParser.COMMA:
                        self.state = 1632
                        self.match(SQLiteParser.COMMA)
                        self.state = 1633
                        self.expr(0)
                        self.state = 1638
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1639
                    self.match(SQLiteParser.CLOSE_PAR)
                    self.state = 1645
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Compound_operatorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_UNION(self):
            return self.getToken(SQLiteParser.K_UNION, 0)

        def K_ALL(self):
            return self.getToken(SQLiteParser.K_ALL, 0)

        def K_INTERSECT(self):
            return self.getToken(SQLiteParser.K_INTERSECT, 0)

        def K_EXCEPT(self):
            return self.getToken(SQLiteParser.K_EXCEPT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_compound_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCompound_operator" ):
                listener.enterCompound_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCompound_operator" ):
                listener.exitCompound_operator(self)




    def compound_operator(self):

        localctx = SQLiteParser.Compound_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_compound_operator)
        try:
            self.state = 1653
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,238,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1648
                self.match(SQLiteParser.K_UNION)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1649
                self.match(SQLiteParser.K_UNION)
                self.state = 1650
                self.match(SQLiteParser.K_ALL)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1651
                self.match(SQLiteParser.K_INTERSECT)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1652
                self.match(SQLiteParser.K_EXCEPT)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Cte_table_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def table_name(self):
            return self.getTypedRuleContext(SQLiteParser.Table_nameContext,0)


        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def column_name(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(SQLiteParser.Column_nameContext)
            else:
                return self.getTypedRuleContext(SQLiteParser.Column_nameContext,i)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(SQLiteParser.COMMA)
            else:
                return self.getToken(SQLiteParser.COMMA, i)

        def getRuleIndex(self):
            return SQLiteParser.RULE_cte_table_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCte_table_name" ):
                listener.enterCte_table_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCte_table_name" ):
                listener.exitCte_table_name(self)




    def cte_table_name(self):

        localctx = SQLiteParser.Cte_table_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_cte_table_name)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1655
            self.table_name()
            self.state = 1667
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.OPEN_PAR:
                self.state = 1656
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1657
                self.column_name()
                self.state = 1662
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==SQLiteParser.COMMA:
                    self.state = 1658
                    self.match(SQLiteParser.COMMA)
                    self.state = 1659
                    self.column_name()
                    self.state = 1664
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1665
                self.match(SQLiteParser.CLOSE_PAR)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Signed_numberContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NUMERIC_LITERAL(self):
            return self.getToken(SQLiteParser.NUMERIC_LITERAL, 0)

        def PLUS(self):
            return self.getToken(SQLiteParser.PLUS, 0)

        def MINUS(self):
            return self.getToken(SQLiteParser.MINUS, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_signed_number

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSigned_number" ):
                listener.enterSigned_number(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSigned_number" ):
                listener.exitSigned_number(self)




    def signed_number(self):

        localctx = SQLiteParser.Signed_numberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_signed_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1670
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==SQLiteParser.PLUS or _la==SQLiteParser.MINUS:
                self.state = 1669
                _la = self._input.LA(1)
                if not(_la==SQLiteParser.PLUS or _la==SQLiteParser.MINUS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 1672
            self.match(SQLiteParser.NUMERIC_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Literal_valueContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NUMERIC_LITERAL(self):
            return self.getToken(SQLiteParser.NUMERIC_LITERAL, 0)

        def STRING_LITERAL(self):
            return self.getToken(SQLiteParser.STRING_LITERAL, 0)

        def BLOB_LITERAL(self):
            return self.getToken(SQLiteParser.BLOB_LITERAL, 0)

        def K_NULL(self):
            return self.getToken(SQLiteParser.K_NULL, 0)

        def K_CURRENT_TIME(self):
            return self.getToken(SQLiteParser.K_CURRENT_TIME, 0)

        def K_CURRENT_DATE(self):
            return self.getToken(SQLiteParser.K_CURRENT_DATE, 0)

        def K_CURRENT_TIMESTAMP(self):
            return self.getToken(SQLiteParser.K_CURRENT_TIMESTAMP, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_literal_value

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLiteral_value" ):
                listener.enterLiteral_value(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLiteral_value" ):
                listener.exitLiteral_value(self)




    def literal_value(self):

        localctx = SQLiteParser.Literal_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_literal_value)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1674
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.K_CURRENT_DATE) | (1 << SQLiteParser.K_CURRENT_TIME) | (1 << SQLiteParser.K_CURRENT_TIMESTAMP))) != 0) or ((((_la - 104)) & ~0x3f) == 0 and ((1 << (_la - 104)) & ((1 << (SQLiteParser.K_NULL - 104)) | (1 << (SQLiteParser.NUMERIC_LITERAL - 104)) | (1 << (SQLiteParser.STRING_LITERAL - 104)) | (1 << (SQLiteParser.BLOB_LITERAL - 104)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Unary_operatorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def MINUS(self):
            return self.getToken(SQLiteParser.MINUS, 0)

        def PLUS(self):
            return self.getToken(SQLiteParser.PLUS, 0)

        def TILDE(self):
            return self.getToken(SQLiteParser.TILDE, 0)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_unary_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnary_operator" ):
                listener.enterUnary_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnary_operator" ):
                listener.exitUnary_operator(self)




    def unary_operator(self):

        localctx = SQLiteParser.Unary_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_unary_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1676
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << SQLiteParser.PLUS) | (1 << SQLiteParser.MINUS) | (1 << SQLiteParser.TILDE))) != 0) or _la==SQLiteParser.K_NOT):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Error_messageContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def STRING_LITERAL(self):
            return self.getToken(SQLiteParser.STRING_LITERAL, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_error_message

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterError_message" ):
                listener.enterError_message(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitError_message" ):
                listener.exitError_message(self)




    def error_message(self):

        localctx = SQLiteParser.Error_messageContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_error_message)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1678
            self.match(SQLiteParser.STRING_LITERAL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Module_argumentContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expr(self):
            return self.getTypedRuleContext(SQLiteParser.ExprContext,0)


        def column_def(self):
            return self.getTypedRuleContext(SQLiteParser.Column_defContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_module_argument

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModule_argument" ):
                listener.enterModule_argument(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModule_argument" ):
                listener.exitModule_argument(self)




    def module_argument(self):

        localctx = SQLiteParser.Module_argumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_module_argument)
        try:
            self.state = 1682
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,242,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1680
                self.expr(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1681
                self.column_def()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Column_aliasContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(SQLiteParser.IDENTIFIER, 0)

        def STRING_LITERAL(self):
            return self.getToken(SQLiteParser.STRING_LITERAL, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_column_alias

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterColumn_alias" ):
                listener.enterColumn_alias(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitColumn_alias" ):
                listener.exitColumn_alias(self)




    def column_alias(self):

        localctx = SQLiteParser.Column_aliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_column_alias)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1684
            _la = self._input.LA(1)
            if not(_la==SQLiteParser.IDENTIFIER or _la==SQLiteParser.STRING_LITERAL):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class KeywordContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def K_ABORT(self):
            return self.getToken(SQLiteParser.K_ABORT, 0)

        def K_ACTION(self):
            return self.getToken(SQLiteParser.K_ACTION, 0)

        def K_ADD(self):
            return self.getToken(SQLiteParser.K_ADD, 0)

        def K_AFTER(self):
            return self.getToken(SQLiteParser.K_AFTER, 0)

        def K_ALL(self):
            return self.getToken(SQLiteParser.K_ALL, 0)

        def K_ALTER(self):
            return self.getToken(SQLiteParser.K_ALTER, 0)

        def K_ANALYZE(self):
            return self.getToken(SQLiteParser.K_ANALYZE, 0)

        def K_AND(self):
            return self.getToken(SQLiteParser.K_AND, 0)

        def K_AS(self):
            return self.getToken(SQLiteParser.K_AS, 0)

        def K_ASC(self):
            return self.getToken(SQLiteParser.K_ASC, 0)

        def K_ATTACH(self):
            return self.getToken(SQLiteParser.K_ATTACH, 0)

        def K_AUTOINCREMENT(self):
            return self.getToken(SQLiteParser.K_AUTOINCREMENT, 0)

        def K_BEFORE(self):
            return self.getToken(SQLiteParser.K_BEFORE, 0)

        def K_BEGIN(self):
            return self.getToken(SQLiteParser.K_BEGIN, 0)

        def K_BETWEEN(self):
            return self.getToken(SQLiteParser.K_BETWEEN, 0)

        def K_BY(self):
            return self.getToken(SQLiteParser.K_BY, 0)

        def K_CASCADE(self):
            return self.getToken(SQLiteParser.K_CASCADE, 0)

        def K_CASE(self):
            return self.getToken(SQLiteParser.K_CASE, 0)

        def K_CAST(self):
            return self.getToken(SQLiteParser.K_CAST, 0)

        def K_CHECK(self):
            return self.getToken(SQLiteParser.K_CHECK, 0)

        def K_COLLATE(self):
            return self.getToken(SQLiteParser.K_COLLATE, 0)

        def K_COLUMN(self):
            return self.getToken(SQLiteParser.K_COLUMN, 0)

        def K_COMMIT(self):
            return self.getToken(SQLiteParser.K_COMMIT, 0)

        def K_CONFLICT(self):
            return self.getToken(SQLiteParser.K_CONFLICT, 0)

        def K_CONSTRAINT(self):
            return self.getToken(SQLiteParser.K_CONSTRAINT, 0)

        def K_CREATE(self):
            return self.getToken(SQLiteParser.K_CREATE, 0)

        def K_CROSS(self):
            return self.getToken(SQLiteParser.K_CROSS, 0)

        def K_CURRENT_DATE(self):
            return self.getToken(SQLiteParser.K_CURRENT_DATE, 0)

        def K_CURRENT_TIME(self):
            return self.getToken(SQLiteParser.K_CURRENT_TIME, 0)

        def K_CURRENT_TIMESTAMP(self):
            return self.getToken(SQLiteParser.K_CURRENT_TIMESTAMP, 0)

        def K_DATABASE(self):
            return self.getToken(SQLiteParser.K_DATABASE, 0)

        def K_DEFAULT(self):
            return self.getToken(SQLiteParser.K_DEFAULT, 0)

        def K_DEFERRABLE(self):
            return self.getToken(SQLiteParser.K_DEFERRABLE, 0)

        def K_DEFERRED(self):
            return self.getToken(SQLiteParser.K_DEFERRED, 0)

        def K_DELETE(self):
            return self.getToken(SQLiteParser.K_DELETE, 0)

        def K_DESC(self):
            return self.getToken(SQLiteParser.K_DESC, 0)

        def K_DETACH(self):
            return self.getToken(SQLiteParser.K_DETACH, 0)

        def K_DISTINCT(self):
            return self.getToken(SQLiteParser.K_DISTINCT, 0)

        def K_DROP(self):
            return self.getToken(SQLiteParser.K_DROP, 0)

        def K_EACH(self):
            return self.getToken(SQLiteParser.K_EACH, 0)

        def K_ELSE(self):
            return self.getToken(SQLiteParser.K_ELSE, 0)

        def K_END(self):
            return self.getToken(SQLiteParser.K_END, 0)

        def K_ESCAPE(self):
            return self.getToken(SQLiteParser.K_ESCAPE, 0)

        def K_EXCEPT(self):
            return self.getToken(SQLiteParser.K_EXCEPT, 0)

        def K_EXCLUSIVE(self):
            return self.getToken(SQLiteParser.K_EXCLUSIVE, 0)

        def K_EXISTS(self):
            return self.getToken(SQLiteParser.K_EXISTS, 0)

        def K_EXPLAIN(self):
            return self.getToken(SQLiteParser.K_EXPLAIN, 0)

        def K_FAIL(self):
            return self.getToken(SQLiteParser.K_FAIL, 0)

        def K_FOR(self):
            return self.getToken(SQLiteParser.K_FOR, 0)

        def K_FOREIGN(self):
            return self.getToken(SQLiteParser.K_FOREIGN, 0)

        def K_FROM(self):
            return self.getToken(SQLiteParser.K_FROM, 0)

        def K_FULL(self):
            return self.getToken(SQLiteParser.K_FULL, 0)

        def K_GLOB(self):
            return self.getToken(SQLiteParser.K_GLOB, 0)

        def K_GROUP(self):
            return self.getToken(SQLiteParser.K_GROUP, 0)

        def K_HAVING(self):
            return self.getToken(SQLiteParser.K_HAVING, 0)

        def K_IF(self):
            return self.getToken(SQLiteParser.K_IF, 0)

        def K_IGNORE(self):
            return self.getToken(SQLiteParser.K_IGNORE, 0)

        def K_IMMEDIATE(self):
            return self.getToken(SQLiteParser.K_IMMEDIATE, 0)

        def K_IN(self):
            return self.getToken(SQLiteParser.K_IN, 0)

        def K_INDEX(self):
            return self.getToken(SQLiteParser.K_INDEX, 0)

        def K_INDEXED(self):
            return self.getToken(SQLiteParser.K_INDEXED, 0)

        def K_INITIALLY(self):
            return self.getToken(SQLiteParser.K_INITIALLY, 0)

        def K_INNER(self):
            return self.getToken(SQLiteParser.K_INNER, 0)

        def K_INSERT(self):
            return self.getToken(SQLiteParser.K_INSERT, 0)

        def K_INSTEAD(self):
            return self.getToken(SQLiteParser.K_INSTEAD, 0)

        def K_INTERSECT(self):
            return self.getToken(SQLiteParser.K_INTERSECT, 0)

        def K_INTO(self):
            return self.getToken(SQLiteParser.K_INTO, 0)

        def K_IS(self):
            return self.getToken(SQLiteParser.K_IS, 0)

        def K_ISNULL(self):
            return self.getToken(SQLiteParser.K_ISNULL, 0)

        def K_JOIN(self):
            return self.getToken(SQLiteParser.K_JOIN, 0)

        def K_KEY(self):
            return self.getToken(SQLiteParser.K_KEY, 0)

        def K_LEFT(self):
            return self.getToken(SQLiteParser.K_LEFT, 0)

        def K_LIKE(self):
            return self.getToken(SQLiteParser.K_LIKE, 0)

        def K_LIMIT(self):
            return self.getToken(SQLiteParser.K_LIMIT, 0)

        def K_MATCH(self):
            return self.getToken(SQLiteParser.K_MATCH, 0)

        def K_NATURAL(self):
            return self.getToken(SQLiteParser.K_NATURAL, 0)

        def K_NO(self):
            return self.getToken(SQLiteParser.K_NO, 0)

        def K_NOT(self):
            return self.getToken(SQLiteParser.K_NOT, 0)

        def K_NOTNULL(self):
            return self.getToken(SQLiteParser.K_NOTNULL, 0)

        def K_NULL(self):
            return self.getToken(SQLiteParser.K_NULL, 0)

        def K_OF(self):
            return self.getToken(SQLiteParser.K_OF, 0)

        def K_OFFSET(self):
            return self.getToken(SQLiteParser.K_OFFSET, 0)

        def K_ON(self):
            return self.getToken(SQLiteParser.K_ON, 0)

        def K_OR(self):
            return self.getToken(SQLiteParser.K_OR, 0)

        def K_ORDER(self):
            return self.getToken(SQLiteParser.K_ORDER, 0)

        def K_OUTER(self):
            return self.getToken(SQLiteParser.K_OUTER, 0)

        def K_PLAN(self):
            return self.getToken(SQLiteParser.K_PLAN, 0)

        def K_PRAGMA(self):
            return self.getToken(SQLiteParser.K_PRAGMA, 0)

        def K_PRIMARY(self):
            return self.getToken(SQLiteParser.K_PRIMARY, 0)

        def K_QUERY(self):
            return self.getToken(SQLiteParser.K_QUERY, 0)

        def K_RAISE(self):
            return self.getToken(SQLiteParser.K_RAISE, 0)

        def K_RECURSIVE(self):
            return self.getToken(SQLiteParser.K_RECURSIVE, 0)

        def K_REFERENCES(self):
            return self.getToken(SQLiteParser.K_REFERENCES, 0)

        def K_REGEXP(self):
            return self.getToken(SQLiteParser.K_REGEXP, 0)

        def K_REINDEX(self):
            return self.getToken(SQLiteParser.K_REINDEX, 0)

        def K_RELEASE(self):
            return self.getToken(SQLiteParser.K_RELEASE, 0)

        def K_RENAME(self):
            return self.getToken(SQLiteParser.K_RENAME, 0)

        def K_REPLACE(self):
            return self.getToken(SQLiteParser.K_REPLACE, 0)

        def K_RESTRICT(self):
            return self.getToken(SQLiteParser.K_RESTRICT, 0)

        def K_RIGHT(self):
            return self.getToken(SQLiteParser.K_RIGHT, 0)

        def K_ROLLBACK(self):
            return self.getToken(SQLiteParser.K_ROLLBACK, 0)

        def K_ROW(self):
            return self.getToken(SQLiteParser.K_ROW, 0)

        def K_SAVEPOINT(self):
            return self.getToken(SQLiteParser.K_SAVEPOINT, 0)

        def K_SELECT(self):
            return self.getToken(SQLiteParser.K_SELECT, 0)

        def K_SET(self):
            return self.getToken(SQLiteParser.K_SET, 0)

        def K_TABLE(self):
            return self.getToken(SQLiteParser.K_TABLE, 0)

        def K_TEMP(self):
            return self.getToken(SQLiteParser.K_TEMP, 0)

        def K_TEMPORARY(self):
            return self.getToken(SQLiteParser.K_TEMPORARY, 0)

        def K_THEN(self):
            return self.getToken(SQLiteParser.K_THEN, 0)

        def K_TO(self):
            return self.getToken(SQLiteParser.K_TO, 0)

        def K_TRANSACTION(self):
            return self.getToken(SQLiteParser.K_TRANSACTION, 0)

        def K_TRIGGER(self):
            return self.getToken(SQLiteParser.K_TRIGGER, 0)

        def K_UNION(self):
            return self.getToken(SQLiteParser.K_UNION, 0)

        def K_UNIQUE(self):
            return self.getToken(SQLiteParser.K_UNIQUE, 0)

        def K_UPDATE(self):
            return self.getToken(SQLiteParser.K_UPDATE, 0)

        def K_USING(self):
            return self.getToken(SQLiteParser.K_USING, 0)

        def K_VACUUM(self):
            return self.getToken(SQLiteParser.K_VACUUM, 0)

        def K_VALUES(self):
            return self.getToken(SQLiteParser.K_VALUES, 0)

        def K_VIEW(self):
            return self.getToken(SQLiteParser.K_VIEW, 0)

        def K_VIRTUAL(self):
            return self.getToken(SQLiteParser.K_VIRTUAL, 0)

        def K_WHEN(self):
            return self.getToken(SQLiteParser.K_WHEN, 0)

        def K_WHERE(self):
            return self.getToken(SQLiteParser.K_WHERE, 0)

        def K_WITH(self):
            return self.getToken(SQLiteParser.K_WITH, 0)

        def K_WITHOUT(self):
            return self.getToken(SQLiteParser.K_WITHOUT, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_keyword

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterKeyword" ):
                listener.enterKeyword(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitKeyword" ):
                listener.exitKeyword(self)




    def keyword(self):

        localctx = SQLiteParser.KeywordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_keyword)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1686
            _la = self._input.LA(1)
            if not(((((_la - 25)) & ~0x3f) == 0 and ((1 << (_la - 25)) & ((1 << (SQLiteParser.K_ABORT - 25)) | (1 << (SQLiteParser.K_ACTION - 25)) | (1 << (SQLiteParser.K_ADD - 25)) | (1 << (SQLiteParser.K_AFTER - 25)) | (1 << (SQLiteParser.K_ALL - 25)) | (1 << (SQLiteParser.K_ALTER - 25)) | (1 << (SQLiteParser.K_ANALYZE - 25)) | (1 << (SQLiteParser.K_AND - 25)) | (1 << (SQLiteParser.K_AS - 25)) | (1 << (SQLiteParser.K_ASC - 25)) | (1 << (SQLiteParser.K_ATTACH - 25)) | (1 << (SQLiteParser.K_AUTOINCREMENT - 25)) | (1 << (SQLiteParser.K_BEFORE - 25)) | (1 << (SQLiteParser.K_BEGIN - 25)) | (1 << (SQLiteParser.K_BETWEEN - 25)) | (1 << (SQLiteParser.K_BY - 25)) | (1 << (SQLiteParser.K_CASCADE - 25)) | (1 << (SQLiteParser.K_CASE - 25)) | (1 << (SQLiteParser.K_CAST - 25)) | (1 << (SQLiteParser.K_CHECK - 25)) | (1 << (SQLiteParser.K_COLLATE - 25)) | (1 << (SQLiteParser.K_COLUMN - 25)) | (1 << (SQLiteParser.K_COMMIT - 25)) | (1 << (SQLiteParser.K_CONFLICT - 25)) | (1 << (SQLiteParser.K_CONSTRAINT - 25)) | (1 << (SQLiteParser.K_CREATE - 25)) | (1 << (SQLiteParser.K_CROSS - 25)) | (1 << (SQLiteParser.K_CURRENT_DATE - 25)) | (1 << (SQLiteParser.K_CURRENT_TIME - 25)) | (1 << (SQLiteParser.K_CURRENT_TIMESTAMP - 25)) | (1 << (SQLiteParser.K_DATABASE - 25)) | (1 << (SQLiteParser.K_DEFAULT - 25)) | (1 << (SQLiteParser.K_DEFERRABLE - 25)) | (1 << (SQLiteParser.K_DEFERRED - 25)) | (1 << (SQLiteParser.K_DELETE - 25)) | (1 << (SQLiteParser.K_DESC - 25)) | (1 << (SQLiteParser.K_DETACH - 25)) | (1 << (SQLiteParser.K_DISTINCT - 25)) | (1 << (SQLiteParser.K_DROP - 25)) | (1 << (SQLiteParser.K_EACH - 25)) | (1 << (SQLiteParser.K_ELSE - 25)) | (1 << (SQLiteParser.K_END - 25)) | (1 << (SQLiteParser.K_ESCAPE - 25)) | (1 << (SQLiteParser.K_EXCEPT - 25)) | (1 << (SQLiteParser.K_EXCLUSIVE - 25)) | (1 << (SQLiteParser.K_EXISTS - 25)) | (1 << (SQLiteParser.K_EXPLAIN - 25)) | (1 << (SQLiteParser.K_FAIL - 25)) | (1 << (SQLiteParser.K_FOR - 25)) | (1 << (SQLiteParser.K_FOREIGN - 25)) | (1 << (SQLiteParser.K_FROM - 25)) | (1 << (SQLiteParser.K_FULL - 25)) | (1 << (SQLiteParser.K_GLOB - 25)) | (1 << (SQLiteParser.K_GROUP - 25)) | (1 << (SQLiteParser.K_HAVING - 25)) | (1 << (SQLiteParser.K_IF - 25)) | (1 << (SQLiteParser.K_IGNORE - 25)) | (1 << (SQLiteParser.K_IMMEDIATE - 25)) | (1 << (SQLiteParser.K_IN - 25)) | (1 << (SQLiteParser.K_INDEX - 25)) | (1 << (SQLiteParser.K_INDEXED - 25)) | (1 << (SQLiteParser.K_INITIALLY - 25)) | (1 << (SQLiteParser.K_INNER - 25)) | (1 << (SQLiteParser.K_INSERT - 25)))) != 0) or ((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & ((1 << (SQLiteParser.K_INSTEAD - 89)) | (1 << (SQLiteParser.K_INTERSECT - 89)) | (1 << (SQLiteParser.K_INTO - 89)) | (1 << (SQLiteParser.K_IS - 89)) | (1 << (SQLiteParser.K_ISNULL - 89)) | (1 << (SQLiteParser.K_JOIN - 89)) | (1 << (SQLiteParser.K_KEY - 89)) | (1 << (SQLiteParser.K_LEFT - 89)) | (1 << (SQLiteParser.K_LIKE - 89)) | (1 << (SQLiteParser.K_LIMIT - 89)) | (1 << (SQLiteParser.K_MATCH - 89)) | (1 << (SQLiteParser.K_NATURAL - 89)) | (1 << (SQLiteParser.K_NO - 89)) | (1 << (SQLiteParser.K_NOT - 89)) | (1 << (SQLiteParser.K_NOTNULL - 89)) | (1 << (SQLiteParser.K_NULL - 89)) | (1 << (SQLiteParser.K_OF - 89)) | (1 << (SQLiteParser.K_OFFSET - 89)) | (1 << (SQLiteParser.K_ON - 89)) | (1 << (SQLiteParser.K_OR - 89)) | (1 << (SQLiteParser.K_ORDER - 89)) | (1 << (SQLiteParser.K_OUTER - 89)) | (1 << (SQLiteParser.K_PLAN - 89)) | (1 << (SQLiteParser.K_PRAGMA - 89)) | (1 << (SQLiteParser.K_PRIMARY - 89)) | (1 << (SQLiteParser.K_QUERY - 89)) | (1 << (SQLiteParser.K_RAISE - 89)) | (1 << (SQLiteParser.K_RECURSIVE - 89)) | (1 << (SQLiteParser.K_REFERENCES - 89)) | (1 << (SQLiteParser.K_REGEXP - 89)) | (1 << (SQLiteParser.K_REINDEX - 89)) | (1 << (SQLiteParser.K_RELEASE - 89)) | (1 << (SQLiteParser.K_RENAME - 89)) | (1 << (SQLiteParser.K_REPLACE - 89)) | (1 << (SQLiteParser.K_RESTRICT - 89)) | (1 << (SQLiteParser.K_RIGHT - 89)) | (1 << (SQLiteParser.K_ROLLBACK - 89)) | (1 << (SQLiteParser.K_ROW - 89)) | (1 << (SQLiteParser.K_SAVEPOINT - 89)) | (1 << (SQLiteParser.K_SELECT - 89)) | (1 << (SQLiteParser.K_SET - 89)) | (1 << (SQLiteParser.K_TABLE - 89)) | (1 << (SQLiteParser.K_TEMP - 89)) | (1 << (SQLiteParser.K_TEMPORARY - 89)) | (1 << (SQLiteParser.K_THEN - 89)) | (1 << (SQLiteParser.K_TO - 89)) | (1 << (SQLiteParser.K_TRANSACTION - 89)) | (1 << (SQLiteParser.K_TRIGGER - 89)) | (1 << (SQLiteParser.K_UNION - 89)) | (1 << (SQLiteParser.K_UNIQUE - 89)) | (1 << (SQLiteParser.K_UPDATE - 89)) | (1 << (SQLiteParser.K_USING - 89)) | (1 << (SQLiteParser.K_VACUUM - 89)) | (1 << (SQLiteParser.K_VALUES - 89)) | (1 << (SQLiteParser.K_VIEW - 89)) | (1 << (SQLiteParser.K_VIRTUAL - 89)) | (1 << (SQLiteParser.K_WHEN - 89)) | (1 << (SQLiteParser.K_WHERE - 89)) | (1 << (SQLiteParser.K_WITH - 89)) | (1 << (SQLiteParser.K_WITHOUT - 89)))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class NameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterName" ):
                listener.enterName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitName" ):
                listener.exitName(self)




    def name(self):

        localctx = SQLiteParser.NameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1688
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Function_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_function_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFunction_name" ):
                listener.enterFunction_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFunction_name" ):
                listener.exitFunction_name(self)




    def function_name(self):

        localctx = SQLiteParser.Function_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_function_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1690
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Database_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_database_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDatabase_name" ):
                listener.enterDatabase_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDatabase_name" ):
                listener.exitDatabase_name(self)




    def database_name(self):

        localctx = SQLiteParser.Database_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_database_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1692
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTable_name" ):
                listener.enterTable_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTable_name" ):
                listener.exitTable_name(self)




    def table_name(self):

        localctx = SQLiteParser.Table_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_table_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1694
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_or_index_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_or_index_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTable_or_index_name" ):
                listener.enterTable_or_index_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTable_or_index_name" ):
                listener.exitTable_or_index_name(self)




    def table_or_index_name(self):

        localctx = SQLiteParser.Table_or_index_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_table_or_index_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1696
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class New_table_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_new_table_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNew_table_name" ):
                listener.enterNew_table_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNew_table_name" ):
                listener.exitNew_table_name(self)




    def new_table_name(self):

        localctx = SQLiteParser.New_table_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_new_table_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1698
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Column_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_column_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterColumn_name" ):
                listener.enterColumn_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitColumn_name" ):
                listener.exitColumn_name(self)




    def column_name(self):

        localctx = SQLiteParser.Column_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_column_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1700
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Collation_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_collation_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCollation_name" ):
                listener.enterCollation_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCollation_name" ):
                listener.exitCollation_name(self)




    def collation_name(self):

        localctx = SQLiteParser.Collation_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_collation_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1702
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Foreign_tableContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_foreign_table

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterForeign_table" ):
                listener.enterForeign_table(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitForeign_table" ):
                listener.exitForeign_table(self)




    def foreign_table(self):

        localctx = SQLiteParser.Foreign_tableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_foreign_table)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1704
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Index_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_index_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIndex_name" ):
                listener.enterIndex_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIndex_name" ):
                listener.exitIndex_name(self)




    def index_name(self):

        localctx = SQLiteParser.Index_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_index_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1706
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Trigger_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_trigger_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTrigger_name" ):
                listener.enterTrigger_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTrigger_name" ):
                listener.exitTrigger_name(self)




    def trigger_name(self):

        localctx = SQLiteParser.Trigger_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_trigger_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1708
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class View_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_view_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterView_name" ):
                listener.enterView_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitView_name" ):
                listener.exitView_name(self)




    def view_name(self):

        localctx = SQLiteParser.View_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_view_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1710
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Module_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_module_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModule_name" ):
                listener.enterModule_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModule_name" ):
                listener.exitModule_name(self)




    def module_name(self):

        localctx = SQLiteParser.Module_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_module_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1712
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Pragma_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_pragma_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPragma_name" ):
                listener.enterPragma_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPragma_name" ):
                listener.exitPragma_name(self)




    def pragma_name(self):

        localctx = SQLiteParser.Pragma_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_pragma_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1714
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Savepoint_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_savepoint_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSavepoint_name" ):
                listener.enterSavepoint_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSavepoint_name" ):
                listener.exitSavepoint_name(self)




    def savepoint_name(self):

        localctx = SQLiteParser.Savepoint_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_savepoint_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1716
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Table_aliasContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_table_alias

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTable_alias" ):
                listener.enterTable_alias(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTable_alias" ):
                listener.exitTable_alias(self)




    def table_alias(self):

        localctx = SQLiteParser.Table_aliasContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_table_alias)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1718
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Transaction_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def getRuleIndex(self):
            return SQLiteParser.RULE_transaction_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTransaction_name" ):
                listener.enterTransaction_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTransaction_name" ):
                listener.exitTransaction_name(self)




    def transaction_name(self):

        localctx = SQLiteParser.Transaction_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_transaction_name)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1720
            self.any_name()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Any_nameContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(SQLiteParser.IDENTIFIER, 0)

        def keyword(self):
            return self.getTypedRuleContext(SQLiteParser.KeywordContext,0)


        def STRING_LITERAL(self):
            return self.getToken(SQLiteParser.STRING_LITERAL, 0)

        def OPEN_PAR(self):
            return self.getToken(SQLiteParser.OPEN_PAR, 0)

        def any_name(self):
            return self.getTypedRuleContext(SQLiteParser.Any_nameContext,0)


        def CLOSE_PAR(self):
            return self.getToken(SQLiteParser.CLOSE_PAR, 0)

        def getRuleIndex(self):
            return SQLiteParser.RULE_any_name

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAny_name" ):
                listener.enterAny_name(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAny_name" ):
                listener.exitAny_name(self)




    def any_name(self):

        localctx = SQLiteParser.Any_nameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_any_name)
        try:
            self.state = 1729
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [SQLiteParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1722
                self.match(SQLiteParser.IDENTIFIER)
                pass
            elif token in [SQLiteParser.K_ABORT, SQLiteParser.K_ACTION, SQLiteParser.K_ADD, SQLiteParser.K_AFTER, SQLiteParser.K_ALL, SQLiteParser.K_ALTER, SQLiteParser.K_ANALYZE, SQLiteParser.K_AND, SQLiteParser.K_AS, SQLiteParser.K_ASC, SQLiteParser.K_ATTACH, SQLiteParser.K_AUTOINCREMENT, SQLiteParser.K_BEFORE, SQLiteParser.K_BEGIN, SQLiteParser.K_BETWEEN, SQLiteParser.K_BY, SQLiteParser.K_CASCADE, SQLiteParser.K_CASE, SQLiteParser.K_CAST, SQLiteParser.K_CHECK, SQLiteParser.K_COLLATE, SQLiteParser.K_COLUMN, SQLiteParser.K_COMMIT, SQLiteParser.K_CONFLICT, SQLiteParser.K_CONSTRAINT, SQLiteParser.K_CREATE, SQLiteParser.K_CROSS, SQLiteParser.K_CURRENT_DATE, SQLiteParser.K_CURRENT_TIME, SQLiteParser.K_CURRENT_TIMESTAMP, SQLiteParser.K_DATABASE, SQLiteParser.K_DEFAULT, SQLiteParser.K_DEFERRABLE, SQLiteParser.K_DEFERRED, SQLiteParser.K_DELETE, SQLiteParser.K_DESC, SQLiteParser.K_DETACH, SQLiteParser.K_DISTINCT, SQLiteParser.K_DROP, SQLiteParser.K_EACH, SQLiteParser.K_ELSE, SQLiteParser.K_END, SQLiteParser.K_ESCAPE, SQLiteParser.K_EXCEPT, SQLiteParser.K_EXCLUSIVE, SQLiteParser.K_EXISTS, SQLiteParser.K_EXPLAIN, SQLiteParser.K_FAIL, SQLiteParser.K_FOR, SQLiteParser.K_FOREIGN, SQLiteParser.K_FROM, SQLiteParser.K_FULL, SQLiteParser.K_GLOB, SQLiteParser.K_GROUP, SQLiteParser.K_HAVING, SQLiteParser.K_IF, SQLiteParser.K_IGNORE, SQLiteParser.K_IMMEDIATE, SQLiteParser.K_IN, SQLiteParser.K_INDEX, SQLiteParser.K_INDEXED, SQLiteParser.K_INITIALLY, SQLiteParser.K_INNER, SQLiteParser.K_INSERT, SQLiteParser.K_INSTEAD, SQLiteParser.K_INTERSECT, SQLiteParser.K_INTO, SQLiteParser.K_IS, SQLiteParser.K_ISNULL, SQLiteParser.K_JOIN, SQLiteParser.K_KEY, SQLiteParser.K_LEFT, SQLiteParser.K_LIKE, SQLiteParser.K_LIMIT, SQLiteParser.K_MATCH, SQLiteParser.K_NATURAL, SQLiteParser.K_NO, SQLiteParser.K_NOT, SQLiteParser.K_NOTNULL, SQLiteParser.K_NULL, SQLiteParser.K_OF, SQLiteParser.K_OFFSET, SQLiteParser.K_ON, SQLiteParser.K_OR, SQLiteParser.K_ORDER, SQLiteParser.K_OUTER, SQLiteParser.K_PLAN, SQLiteParser.K_PRAGMA, SQLiteParser.K_PRIMARY, SQLiteParser.K_QUERY, SQLiteParser.K_RAISE, SQLiteParser.K_RECURSIVE, SQLiteParser.K_REFERENCES, SQLiteParser.K_REGEXP, SQLiteParser.K_REINDEX, SQLiteParser.K_RELEASE, SQLiteParser.K_RENAME, SQLiteParser.K_REPLACE, SQLiteParser.K_RESTRICT, SQLiteParser.K_RIGHT, SQLiteParser.K_ROLLBACK, SQLiteParser.K_ROW, SQLiteParser.K_SAVEPOINT, SQLiteParser.K_SELECT, SQLiteParser.K_SET, SQLiteParser.K_TABLE, SQLiteParser.K_TEMP, SQLiteParser.K_TEMPORARY, SQLiteParser.K_THEN, SQLiteParser.K_TO, SQLiteParser.K_TRANSACTION, SQLiteParser.K_TRIGGER, SQLiteParser.K_UNION, SQLiteParser.K_UNIQUE, SQLiteParser.K_UPDATE, SQLiteParser.K_USING, SQLiteParser.K_VACUUM, SQLiteParser.K_VALUES, SQLiteParser.K_VIEW, SQLiteParser.K_VIRTUAL, SQLiteParser.K_WHEN, SQLiteParser.K_WHERE, SQLiteParser.K_WITH, SQLiteParser.K_WITHOUT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1723
                self.keyword()
                pass
            elif token in [SQLiteParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1724
                self.match(SQLiteParser.STRING_LITERAL)
                pass
            elif token in [SQLiteParser.OPEN_PAR]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1725
                self.match(SQLiteParser.OPEN_PAR)
                self.state = 1726
                self.any_name()
                self.state = 1727
                self.match(SQLiteParser.CLOSE_PAR)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[39] = self.expr_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def expr_sempred(self, localctx:ExprContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 20)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 19)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 18)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 17)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 16)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 15)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 14)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 13)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 13:
                return self.precpred(self._ctx, 4)
         




