Fossil SCM

Update the built-in SQLite to the latest trunk version.

drh 2021-06-03 23:10 trunk

Commit 4add0ac52906f758c0a6651a5c5d38b3c0a4eee8bb23239e18d420d3ee58c484

Parent 1f3a053b1613f2c…

3 files changed +791 -6 +1834 -1652 +1 -1

~ src/shell.c ~ src/sqlite3.c ~ src/sqlite3.h

M src/shell.c

+791 -6

		--- src/shell.c
		+++ src/shell.c
		@@ -5879,10 +5879,779 @@
5879	5879	#endif
5880	5880	return rc;
5881	5881	}
5882	5882
5883	5883	/*********************** End ../ext/misc/series.c ******************/
	5884	+/*********************** Begin ../ext/misc/regexp.c ****************/
	5885	+/*
	5886	+** 2012-11-13
	5887	+**
	5888	+** The author disclaims copyright to this source code. In place of
	5889	+** a legal notice, here is a blessing:
	5890	+**
	5891	+** May you do good and not evil.
	5892	+** May you find forgiveness for yourself and forgive others.
	5893	+** May you share freely, never taking more than you give.
	5894	+**
	5895	+******************************************************************************
	5896	+**
	5897	+** The code in this file implements a compact but reasonably
	5898	+** efficient regular-expression matcher for posix extended regular
	5899	+** expressions against UTF8 text.
	5900	+**
	5901	+** This file is an SQLite extension. It registers a single function
	5902	+** named "regexp(A,B)" where A is the regular expression and B is the
	5903	+** string to be matched. By registering this function, SQLite will also
	5904	+** then implement the "B regexp A" operator. Note that with the function
	5905	+** the regular expression comes first, but with the operator it comes
	5906	+** second.
	5907	+**
	5908	+** The following regular expression syntax is supported:
	5909	+**
	5910	+** X* zero or more occurrences of X
	5911	+** X+ one or more occurrences of X
	5912	+** X? zero or one occurrences of X
	5913	+** X{p,q} between p and q occurrences of X
	5914	+** (X) match X
	5915	+** X\|Y X or Y
	5916	+** ^X X occurring at the beginning of the string
	5917	+** X$ X occurring at the end of the string
	5918	+** . Match any single character
	5919	+** \c Character c where c is one of \{}()[]\|*+?.
	5920	+** \c C-language escapes for c in afnrtv. ex: \t or \n
	5921	+** \uXXXX Where XXXX is exactly 4 hex digits, unicode value XXXX
	5922	+** \xXX Where XX is exactly 2 hex digits, unicode value XX
	5923	+** [abc] Any single character from the set abc
	5924	+** [^abc] Any single character not in the set abc
	5925	+** [a-z] Any single character in the range a-z
	5926	+** [^a-z] Any single character not in the range a-z
	5927	+** \b Word boundary
	5928	+** \w Word character. [A-Za-z0-9_]
	5929	+** \W Non-word character
	5930	+** \d Digit
	5931	+** \D Non-digit
	5932	+** \s Whitespace character
	5933	+** \S Non-whitespace character
	5934	+**
	5935	+** A nondeterministic finite automaton (NFA) is used for matching, so the
	5936	+** performance is bounded by O(N*M) where N is the size of the regular
	5937	+** expression and M is the size of the input string. The matcher never
	5938	+** exhibits exponential behavior. Note that the X{p,q} operator expands
	5939	+** to p copies of X following by q-p copies of X? and that the size of the
	5940	+** regular expression in the O(N*M) performance bound is computed after
	5941	+** this expansion.
	5942	+*/
	5943	+#include <string.h>
	5944	+#include <stdlib.h>
	5945	+/* #include "sqlite3ext.h" */
	5946	+SQLITE_EXTENSION_INIT1
	5947	+
	5948	+/*
	5949	+** The following #defines change the names of some functions implemented in
	5950	+** this file to prevent name collisions with C-library functions of the
	5951	+** same name.
	5952	+*/
	5953	+#define re_match sqlite3re_match
	5954	+#define re_compile sqlite3re_compile
	5955	+#define re_free sqlite3re_free
	5956	+
	5957	+/* The end-of-input character */
	5958	+#define RE_EOF 0 /* End of input */
	5959	+
	5960	+/* The NFA is implemented as sequence of opcodes taken from the following
	5961	+** set. Each opcode has a single integer argument.
	5962	+*/
	5963	+#define RE_OP_MATCH 1 /* Match the one character in the argument */
	5964	+#define RE_OP_ANY 2 /* Match any one character. (Implements ".") */
	5965	+#define RE_OP_ANYSTAR 3 /* Special optimized version of .* */
	5966	+#define RE_OP_FORK 4 /* Continue to both next and opcode at iArg */
	5967	+#define RE_OP_GOTO 5 /* Jump to opcode at iArg */
	5968	+#define RE_OP_ACCEPT 6 /* Halt and indicate a successful match */
	5969	+#define RE_OP_CC_INC 7 /* Beginning of a [...] character class */
	5970	+#define RE_OP_CC_EXC 8 /* Beginning of a [^...] character class */
	5971	+#define RE_OP_CC_VALUE 9 /* Single value in a character class */
	5972	+#define RE_OP_CC_RANGE 10 /* Range of values in a character class */
	5973	+#define RE_OP_WORD 11 /* Perl word character [A-Za-z0-9_] */
	5974	+#define RE_OP_NOTWORD 12 /* Not a perl word character */
	5975	+#define RE_OP_DIGIT 13 /* digit: [0-9] */
	5976	+#define RE_OP_NOTDIGIT 14 /* Not a digit */
	5977	+#define RE_OP_SPACE 15 /* space: [ \t\n\r\v\f] */
	5978	+#define RE_OP_NOTSPACE 16 /* Not a digit */
	5979	+#define RE_OP_BOUNDARY 17 /* Boundary between word and non-word */
	5980	+
	5981	+/* Each opcode is a "state" in the NFA */
	5982	+typedef unsigned short ReStateNumber;
	5983	+
	5984	+/* Because this is an NFA and not a DFA, multiple states can be active at
	5985	+** once. An instance of the following object records all active states in
	5986	+** the NFA. The implementation is optimized for the common case where the
	5987	+** number of actives states is small.
	5988	+*/
	5989	+typedef struct ReStateSet {
	5990	+ unsigned nState; /* Number of current states */
	5991	+ ReStateNumber aState; / Current states */
	5992	+} ReStateSet;
	5993	+
	5994	+/* An input string read one character at a time.
	5995	+*/
	5996	+typedef struct ReInput ReInput;
	5997	+struct ReInput {
	5998	+ const unsigned char z; / All text */
	5999	+ int i; /* Next byte to read */
	6000	+ int mx; /* EOF when i>=mx */
	6001	+};
	6002	+
	6003	+/* A compiled NFA (or an NFA that is in the process of being compiled) is
	6004	+** an instance of the following object.
	6005	+*/
	6006	+typedef struct ReCompiled ReCompiled;
	6007	+struct ReCompiled {
	6008	+ ReInput sIn; /* Regular expression text */
	6009	+ const char zErr; / Error message to return */
	6010	+ char aOp; / Operators for the virtual machine */
	6011	+ int aArg; / Arguments to each operator */
	6012	+ unsigned (xNextChar)(ReInput); /* Next character function */
	6013	+ unsigned char zInit[12]; /* Initial text to match */
	6014	+ int nInit; /* Number of characters in zInit */
	6015	+ unsigned nState; /* Number of entries in aOp[] and aArg[] */
	6016	+ unsigned nAlloc; /* Slots allocated for aOp[] and aArg[] */
	6017	+};
	6018	+
	6019	+/* Add a state to the given state set if it is not already there */
	6020	+static void re_add_state(ReStateSet *pSet, int newState){
	6021	+ unsigned i;
	6022	+ for(i=0; i<pSet->nState; i++) if( pSet->aState[i]==newState ) return;
	6023	+ pSet->aState[pSet->nState++] = (ReStateNumber)newState;
	6024	+}
	6025	+
	6026	+/* Extract the next unicode character from *pzIn and return it. Advance
	6027	+** *pzIn to the first byte past the end of the character returned. To
	6028	+** be clear: this routine converts utf8 to unicode. This routine is
	6029	+** optimized for the common case where the next character is a single byte.
	6030	+*/
	6031	+static unsigned re_next_char(ReInput *p){
	6032	+ unsigned c;
	6033	+ if( p->i>=p->mx ) return 0;
	6034	+ c = p->z[p->i++];
	6035	+ if( c>=0x80 ){
	6036	+ if( (c&0xe0)==0xc0 && p->i<p->mx && (p->z[p->i]&0xc0)==0x80 ){
	6037	+ c = (c&0x1f)<<6 \| (p->z[p->i++]&0x3f);
	6038	+ if( c<0x80 ) c = 0xfffd;
	6039	+ }else if( (c&0xf0)==0xe0 && p->i+1<p->mx && (p->z[p->i]&0xc0)==0x80
	6040	+ && (p->z[p->i+1]&0xc0)==0x80 ){
	6041	+ c = (c&0x0f)<<12 \| ((p->z[p->i]&0x3f)<<6) \| (p->z[p->i+1]&0x3f);
	6042	+ p->i += 2;
	6043	+ if( c<=0x7ff \|\| (c>=0xd800 && c<=0xdfff) ) c = 0xfffd;
	6044	+ }else if( (c&0xf8)==0xf0 && p->i+3<p->mx && (p->z[p->i]&0xc0)==0x80
	6045	+ && (p->z[p->i+1]&0xc0)==0x80 && (p->z[p->i+2]&0xc0)==0x80 ){
	6046	+ c = (c&0x07)<<18 \| ((p->z[p->i]&0x3f)<<12) \| ((p->z[p->i+1]&0x3f)<<6)
	6047	+ \| (p->z[p->i+2]&0x3f);
	6048	+ p->i += 3;
	6049	+ if( c<=0xffff \|\| c>0x10ffff ) c = 0xfffd;
	6050	+ }else{
	6051	+ c = 0xfffd;
	6052	+ }
	6053	+ }
	6054	+ return c;
	6055	+}
	6056	+static unsigned re_next_char_nocase(ReInput *p){
	6057	+ unsigned c = re_next_char(p);
	6058	+ if( c>='A' && c<='Z' ) c += 'a' - 'A';
	6059	+ return c;
	6060	+}
	6061	+
	6062	+/* Return true if c is a perl "word" character: [A-Za-z0-9_] */
	6063	+static int re_word_char(int c){
	6064	+ return (c>='0' && c<='9') \|\| (c>='a' && c<='z')
	6065	+ \|\| (c>='A' && c<='Z') \|\| c=='_';
	6066	+}
	6067	+
	6068	+/* Return true if c is a "digit" character: [0-9] */
	6069	+static int re_digit_char(int c){
	6070	+ return (c>='0' && c<='9');
	6071	+}
	6072	+
	6073	+/* Return true if c is a perl "space" character: [ \t\r\n\v\f] */
	6074	+static int re_space_char(int c){
	6075	+ return c==' ' \|\| c=='\t' \|\| c=='\n' \|\| c=='\r' \|\| c=='\v' \|\| c=='\f';
	6076	+}
	6077	+
	6078	+/* Run a compiled regular expression on the zero-terminated input
	6079	+** string zIn[]. Return true on a match and false if there is no match.
	6080	+*/
	6081	+static int re_match(ReCompiled pRe, const unsigned char zIn, int nIn){
	6082	+ ReStateSet aStateSet[2], pThis, pNext;
	6083	+ ReStateNumber aSpace[100];
	6084	+ ReStateNumber *pToFree;
	6085	+ unsigned int i = 0;
	6086	+ unsigned int iSwap = 0;
	6087	+ int c = RE_EOF+1;
	6088	+ int cPrev = 0;
	6089	+ int rc = 0;
	6090	+ ReInput in;
	6091	+
	6092	+ in.z = zIn;
	6093	+ in.i = 0;
	6094	+ in.mx = nIn>=0 ? nIn : (int)strlen((char const*)zIn);
	6095	+
	6096	+ /* Look for the initial prefix match, if there is one. */
	6097	+ if( pRe->nInit ){
	6098	+ unsigned char x = pRe->zInit[0];
	6099	+ while( in.i+pRe->nInit<=in.mx
	6100	+ && (zIn[in.i]!=x \|\|
	6101	+ strncmp((const char)zIn+in.i, (const char)pRe->zInit, pRe->nInit)!=0)
	6102	+ ){
	6103	+ in.i++;
	6104	+ }
	6105	+ if( in.i+pRe->nInit>in.mx ) return 0;
	6106	+ }
	6107	+
	6108	+ if( pRe->nState<=(sizeof(aSpace)/(sizeof(aSpace[0])*2)) ){
	6109	+ pToFree = 0;
	6110	+ aStateSet[0].aState = aSpace;
	6111	+ }else{
	6112	+ pToFree = sqlite3_malloc64( sizeof(ReStateNumber)2pRe->nState );
	6113	+ if( pToFree==0 ) return -1;
	6114	+ aStateSet[0].aState = pToFree;
	6115	+ }
	6116	+ aStateSet[1].aState = &aStateSet[0].aState[pRe->nState];
	6117	+ pNext = &aStateSet[1];
	6118	+ pNext->nState = 0;
	6119	+ re_add_state(pNext, 0);
	6120	+ while( c!=RE_EOF && pNext->nState>0 ){
	6121	+ cPrev = c;
	6122	+ c = pRe->xNextChar(&in);
	6123	+ pThis = pNext;
	6124	+ pNext = &aStateSet[iSwap];
	6125	+ iSwap = 1 - iSwap;
	6126	+ pNext->nState = 0;
	6127	+ for(i=0; i<pThis->nState; i++){
	6128	+ int x = pThis->aState[i];
	6129	+ switch( pRe->aOp[x] ){
	6130	+ case RE_OP_MATCH: {
	6131	+ if( pRe->aArg[x]==c ) re_add_state(pNext, x+1);
	6132	+ break;
	6133	+ }
	6134	+ case RE_OP_ANY: {
	6135	+ if( c!=0 ) re_add_state(pNext, x+1);
	6136	+ break;
	6137	+ }
	6138	+ case RE_OP_WORD: {
	6139	+ if( re_word_char(c) ) re_add_state(pNext, x+1);
	6140	+ break;
	6141	+ }
	6142	+ case RE_OP_NOTWORD: {
	6143	+ if( !re_word_char(c) ) re_add_state(pNext, x+1);
	6144	+ break;
	6145	+ }
	6146	+ case RE_OP_DIGIT: {
	6147	+ if( re_digit_char(c) ) re_add_state(pNext, x+1);
	6148	+ break;
	6149	+ }
	6150	+ case RE_OP_NOTDIGIT: {
	6151	+ if( !re_digit_char(c) ) re_add_state(pNext, x+1);
	6152	+ break;
	6153	+ }
	6154	+ case RE_OP_SPACE: {
	6155	+ if( re_space_char(c) ) re_add_state(pNext, x+1);
	6156	+ break;
	6157	+ }
	6158	+ case RE_OP_NOTSPACE: {
	6159	+ if( !re_space_char(c) ) re_add_state(pNext, x+1);
	6160	+ break;
	6161	+ }
	6162	+ case RE_OP_BOUNDARY: {
	6163	+ if( re_word_char(c)!=re_word_char(cPrev) ) re_add_state(pThis, x+1);
	6164	+ break;
	6165	+ }
	6166	+ case RE_OP_ANYSTAR: {
	6167	+ re_add_state(pNext, x);
	6168	+ re_add_state(pThis, x+1);
	6169	+ break;
	6170	+ }
	6171	+ case RE_OP_FORK: {
	6172	+ re_add_state(pThis, x+pRe->aArg[x]);
	6173	+ re_add_state(pThis, x+1);
	6174	+ break;
	6175	+ }
	6176	+ case RE_OP_GOTO: {
	6177	+ re_add_state(pThis, x+pRe->aArg[x]);
	6178	+ break;
	6179	+ }
	6180	+ case RE_OP_ACCEPT: {
	6181	+ rc = 1;
	6182	+ goto re_match_end;
	6183	+ }
	6184	+ case RE_OP_CC_INC:
	6185	+ case RE_OP_CC_EXC: {
	6186	+ int j = 1;
	6187	+ int n = pRe->aArg[x];
	6188	+ int hit = 0;
	6189	+ for(j=1; j>0 && j<n; j++){
	6190	+ if( pRe->aOp[x+j]==RE_OP_CC_VALUE ){
	6191	+ if( pRe->aArg[x+j]==c ){
	6192	+ hit = 1;
	6193	+ j = -1;
	6194	+ }
	6195	+ }else{
	6196	+ if( pRe->aArg[x+j]<=c && pRe->aArg[x+j+1]>=c ){
	6197	+ hit = 1;
	6198	+ j = -1;
	6199	+ }else{
	6200	+ j++;
	6201	+ }
	6202	+ }
	6203	+ }
	6204	+ if( pRe->aOp[x]==RE_OP_CC_EXC ) hit = !hit;
	6205	+ if( hit ) re_add_state(pNext, x+n);
	6206	+ break;
	6207	+ }
	6208	+ }
	6209	+ }
	6210	+ }
	6211	+ for(i=0; i<pNext->nState; i++){
	6212	+ if( pRe->aOp[pNext->aState[i]]==RE_OP_ACCEPT ){ rc = 1; break; }
	6213	+ }
	6214	+re_match_end:
	6215	+ sqlite3_free(pToFree);
	6216	+ return rc;
	6217	+}
	6218	+
	6219	+/* Resize the opcode and argument arrays for an RE under construction.
	6220	+*/
	6221	+static int re_resize(ReCompiled *p, int N){
	6222	+ char *aOp;
	6223	+ int *aArg;
	6224	+ aOp = sqlite3_realloc64(p->aOp, N*sizeof(p->aOp[0]));
	6225	+ if( aOp==0 ) return 1;
	6226	+ p->aOp = aOp;
	6227	+ aArg = sqlite3_realloc64(p->aArg, N*sizeof(p->aArg[0]));
	6228	+ if( aArg==0 ) return 1;
	6229	+ p->aArg = aArg;
	6230	+ p->nAlloc = N;
	6231	+ return 0;
	6232	+}
	6233	+
	6234	+/* Insert a new opcode and argument into an RE under construction. The
	6235	+** insertion point is just prior to existing opcode iBefore.
	6236	+*/
	6237	+static int re_insert(ReCompiled *p, int iBefore, int op, int arg){
	6238	+ int i;
	6239	+ if( p->nAlloc<=p->nState && re_resize(p, p->nAlloc*2) ) return 0;
	6240	+ for(i=p->nState; i>iBefore; i--){
	6241	+ p->aOp[i] = p->aOp[i-1];
	6242	+ p->aArg[i] = p->aArg[i-1];
	6243	+ }
	6244	+ p->nState++;
	6245	+ p->aOp[iBefore] = (char)op;
	6246	+ p->aArg[iBefore] = arg;
	6247	+ return iBefore;
	6248	+}
	6249	+
	6250	+/* Append a new opcode and argument to the end of the RE under construction.
	6251	+*/
	6252	+static int re_append(ReCompiled *p, int op, int arg){
	6253	+ return re_insert(p, p->nState, op, arg);
	6254	+}
	6255	+
	6256	+/* Make a copy of N opcodes starting at iStart onto the end of the RE
	6257	+** under construction.
	6258	+*/
	6259	+static void re_copy(ReCompiled *p, int iStart, int N){
	6260	+ if( p->nState+N>=p->nAlloc && re_resize(p, p->nAlloc*2+N) ) return;
	6261	+ memcpy(&p->aOp[p->nState], &p->aOp[iStart], N*sizeof(p->aOp[0]));
	6262	+ memcpy(&p->aArg[p->nState], &p->aArg[iStart], N*sizeof(p->aArg[0]));
	6263	+ p->nState += N;
	6264	+}
	6265	+
	6266	+/* Return true if c is a hexadecimal digit character: [0-9a-fA-F]
	6267	+** If c is a hex digit, also set pV = (pV)*16 + valueof(c). If
	6268	+** c is not a hex digit *pV is unchanged.
	6269	+*/
	6270	+static int re_hex(int c, int *pV){
	6271	+ if( c>='0' && c<='9' ){
	6272	+ c -= '0';
	6273	+ }else if( c>='a' && c<='f' ){
	6274	+ c -= 'a' - 10;
	6275	+ }else if( c>='A' && c<='F' ){
	6276	+ c -= 'A' - 10;
	6277	+ }else{
	6278	+ return 0;
	6279	+ }
	6280	+ pV = (pV)*16 + (c & 0xff);
	6281	+ return 1;
	6282	+}
	6283	+
	6284	+/* A backslash character has been seen, read the next character and
	6285	+** return its interpretation.
	6286	+*/
	6287	+static unsigned re_esc_char(ReCompiled *p){
	6288	+ static const char zEsc[] = "afnrtv\\()*.+?[$^{\|}]";
	6289	+ static const char zTrans[] = "\a\f\n\r\t\v";
	6290	+ int i, v = 0;
	6291	+ char c;
	6292	+ if( p->sIn.i>=p->sIn.mx ) return 0;
	6293	+ c = p->sIn.z[p->sIn.i];
	6294	+ if( c=='u' && p->sIn.i+4<p->sIn.mx ){
	6295	+ const unsigned char *zIn = p->sIn.z + p->sIn.i;
	6296	+ if( re_hex(zIn[1],&v)
	6297	+ && re_hex(zIn[2],&v)
	6298	+ && re_hex(zIn[3],&v)
	6299	+ && re_hex(zIn[4],&v)
	6300	+ ){
	6301	+ p->sIn.i += 5;
	6302	+ return v;
	6303	+ }
	6304	+ }
	6305	+ if( c=='x' && p->sIn.i+2<p->sIn.mx ){
	6306	+ const unsigned char *zIn = p->sIn.z + p->sIn.i;
	6307	+ if( re_hex(zIn[1],&v)
	6308	+ && re_hex(zIn[2],&v)
	6309	+ ){
	6310	+ p->sIn.i += 3;
	6311	+ return v;
	6312	+ }
	6313	+ }
	6314	+ for(i=0; zEsc[i] && zEsc[i]!=c; i++){}
	6315	+ if( zEsc[i] ){
	6316	+ if( i<6 ) c = zTrans[i];
	6317	+ p->sIn.i++;
	6318	+ }else{
	6319	+ p->zErr = "unknown \\ escape";
	6320	+ }
	6321	+ return c;
	6322	+}
	6323	+
	6324	+/* Forward declaration */
	6325	+static const char re_subcompile_string(ReCompiled);
	6326	+
	6327	+/* Peek at the next byte of input */
	6328	+static unsigned char rePeek(ReCompiled *p){
	6329	+ return p->sIn.i<p->sIn.mx ? p->sIn.z[p->sIn.i] : 0;
	6330	+}
	6331	+
	6332	+/* Compile RE text into a sequence of opcodes. Continue up to the
	6333	+** first unmatched ")" character, then return. If an error is found,
	6334	+** return a pointer to the error message string.
	6335	+*/
	6336	+static const char re_subcompile_re(ReCompiled p){
	6337	+ const char *zErr;
	6338	+ int iStart, iEnd, iGoto;
	6339	+ iStart = p->nState;
	6340	+ zErr = re_subcompile_string(p);
	6341	+ if( zErr ) return zErr;
	6342	+ while( rePeek(p)=='\|' ){
	6343	+ iEnd = p->nState;
	6344	+ re_insert(p, iStart, RE_OP_FORK, iEnd + 2 - iStart);
	6345	+ iGoto = re_append(p, RE_OP_GOTO, 0);
	6346	+ p->sIn.i++;
	6347	+ zErr = re_subcompile_string(p);
	6348	+ if( zErr ) return zErr;
	6349	+ p->aArg[iGoto] = p->nState - iGoto;
	6350	+ }
	6351	+ return 0;
	6352	+}
	6353	+
	6354	+/* Compile an element of regular expression text (anything that can be
	6355	+** an operand to the "\|" operator). Return NULL on success or a pointer
	6356	+** to the error message if there is a problem.
	6357	+*/
	6358	+static const char re_subcompile_string(ReCompiled p){
	6359	+ int iPrev = -1;
	6360	+ int iStart;
	6361	+ unsigned c;
	6362	+ const char *zErr;
	6363	+ while( (c = p->xNextChar(&p->sIn))!=0 ){
	6364	+ iStart = p->nState;
	6365	+ switch( c ){
	6366	+ case '\|':
	6367	+ case '$':
	6368	+ case ')': {
	6369	+ p->sIn.i--;
	6370	+ return 0;
	6371	+ }
	6372	+ case '(': {
	6373	+ zErr = re_subcompile_re(p);
	6374	+ if( zErr ) return zErr;
	6375	+ if( rePeek(p)!=')' ) return "unmatched '('";
	6376	+ p->sIn.i++;
	6377	+ break;
	6378	+ }
	6379	+ case '.': {
	6380	+ if( rePeek(p)=='*' ){
	6381	+ re_append(p, RE_OP_ANYSTAR, 0);
	6382	+ p->sIn.i++;
	6383	+ }else{
	6384	+ re_append(p, RE_OP_ANY, 0);
	6385	+ }
	6386	+ break;
	6387	+ }
	6388	+ case '*': {
	6389	+ if( iPrev<0 ) return "'*' without operand";
	6390	+ re_insert(p, iPrev, RE_OP_GOTO, p->nState - iPrev + 1);
	6391	+ re_append(p, RE_OP_FORK, iPrev - p->nState + 1);
	6392	+ break;
	6393	+ }
	6394	+ case '+': {
	6395	+ if( iPrev<0 ) return "'+' without operand";
	6396	+ re_append(p, RE_OP_FORK, iPrev - p->nState);
	6397	+ break;
	6398	+ }
	6399	+ case '?': {
	6400	+ if( iPrev<0 ) return "'?' without operand";
	6401	+ re_insert(p, iPrev, RE_OP_FORK, p->nState - iPrev+1);
	6402	+ break;
	6403	+ }
	6404	+ case '{': {
	6405	+ int m = 0, n = 0;
	6406	+ int sz, j;
	6407	+ if( iPrev<0 ) return "'{m,n}' without operand";
	6408	+ while( (c=rePeek(p))>='0' && c<='9' ){ m = m*10 + c - '0'; p->sIn.i++; }
	6409	+ n = m;
	6410	+ if( c==',' ){
	6411	+ p->sIn.i++;
	6412	+ n = 0;
	6413	+ while( (c=rePeek(p))>='0' && c<='9' ){ n = n*10 + c-'0'; p->sIn.i++; }
	6414	+ }
	6415	+ if( c!='}' ) return "unmatched '{'";
	6416	+ if( n>0 && n<m ) return "n less than m in '{m,n}'";
	6417	+ p->sIn.i++;
	6418	+ sz = p->nState - iPrev;
	6419	+ if( m==0 ){
	6420	+ if( n==0 ) return "both m and n are zero in '{m,n}'";
	6421	+ re_insert(p, iPrev, RE_OP_FORK, sz+1);
	6422	+ n--;
	6423	+ }else{
	6424	+ for(j=1; j<m; j++) re_copy(p, iPrev, sz);
	6425	+ }
	6426	+ for(j=m; j<n; j++){
	6427	+ re_append(p, RE_OP_FORK, sz+1);
	6428	+ re_copy(p, iPrev, sz);
	6429	+ }
	6430	+ if( n==0 && m>0 ){
	6431	+ re_append(p, RE_OP_FORK, -sz);
	6432	+ }
	6433	+ break;
	6434	+ }
	6435	+ case '[': {
	6436	+ int iFirst = p->nState;
	6437	+ if( rePeek(p)=='^' ){
	6438	+ re_append(p, RE_OP_CC_EXC, 0);
	6439	+ p->sIn.i++;
	6440	+ }else{
	6441	+ re_append(p, RE_OP_CC_INC, 0);
	6442	+ }
	6443	+ while( (c = p->xNextChar(&p->sIn))!=0 ){
	6444	+ if( c=='[' && rePeek(p)==':' ){
	6445	+ return "POSIX character classes not supported";
	6446	+ }
	6447	+ if( c=='\\' ) c = re_esc_char(p);
	6448	+ if( rePeek(p)=='-' ){
	6449	+ re_append(p, RE_OP_CC_RANGE, c);
	6450	+ p->sIn.i++;
	6451	+ c = p->xNextChar(&p->sIn);
	6452	+ if( c=='\\' ) c = re_esc_char(p);
	6453	+ re_append(p, RE_OP_CC_RANGE, c);
	6454	+ }else{
	6455	+ re_append(p, RE_OP_CC_VALUE, c);
	6456	+ }
	6457	+ if( rePeek(p)==']' ){ p->sIn.i++; break; }
	6458	+ }
	6459	+ if( c==0 ) return "unclosed '['";
	6460	+ p->aArg[iFirst] = p->nState - iFirst;
	6461	+ break;
	6462	+ }
	6463	+ case '\\': {
	6464	+ int specialOp = 0;
	6465	+ switch( rePeek(p) ){
	6466	+ case 'b': specialOp = RE_OP_BOUNDARY; break;
	6467	+ case 'd': specialOp = RE_OP_DIGIT; break;
	6468	+ case 'D': specialOp = RE_OP_NOTDIGIT; break;
	6469	+ case 's': specialOp = RE_OP_SPACE; break;
	6470	+ case 'S': specialOp = RE_OP_NOTSPACE; break;
	6471	+ case 'w': specialOp = RE_OP_WORD; break;
	6472	+ case 'W': specialOp = RE_OP_NOTWORD; break;
	6473	+ }
	6474	+ if( specialOp ){
	6475	+ p->sIn.i++;
	6476	+ re_append(p, specialOp, 0);
	6477	+ }else{
	6478	+ c = re_esc_char(p);
	6479	+ re_append(p, RE_OP_MATCH, c);
	6480	+ }
	6481	+ break;
	6482	+ }
	6483	+ default: {
	6484	+ re_append(p, RE_OP_MATCH, c);
	6485	+ break;
	6486	+ }
	6487	+ }
	6488	+ iPrev = iStart;
	6489	+ }
	6490	+ return 0;
	6491	+}
	6492	+
	6493	+/* Free and reclaim all the memory used by a previously compiled
	6494	+** regular expression. Applications should invoke this routine once
	6495	+** for every call to re_compile() to avoid memory leaks.
	6496	+*/
	6497	+static void re_free(ReCompiled *pRe){
	6498	+ if( pRe ){
	6499	+ sqlite3_free(pRe->aOp);
	6500	+ sqlite3_free(pRe->aArg);
	6501	+ sqlite3_free(pRe);
	6502	+ }
	6503	+}
	6504	+
	6505	+/*
	6506	+** Compile a textual regular expression in zIn[] into a compiled regular
	6507	+** expression suitable for us by re_match() and return a pointer to the
	6508	+** compiled regular expression in *ppRe. Return NULL on success or an
	6509	+** error message if something goes wrong.
	6510	+*/
	6511	+static const char re_compile(ReCompiled ppRe, const char zIn, int noCase){
	6512	+ ReCompiled *pRe;
	6513	+ const char *zErr;
	6514	+ int i, j;
	6515	+
	6516	+ *ppRe = 0;
	6517	+ pRe = sqlite3_malloc( sizeof(*pRe) );
	6518	+ if( pRe==0 ){
	6519	+ return "out of memory";
	6520	+ }
	6521	+ memset(pRe, 0, sizeof(*pRe));
	6522	+ pRe->xNextChar = noCase ? re_next_char_nocase : re_next_char;
	6523	+ if( re_resize(pRe, 30) ){
	6524	+ re_free(pRe);
	6525	+ return "out of memory";
	6526	+ }
	6527	+ if( zIn[0]=='^' ){
	6528	+ zIn++;
	6529	+ }else{
	6530	+ re_append(pRe, RE_OP_ANYSTAR, 0);
	6531	+ }
	6532	+ pRe->sIn.z = (unsigned char*)zIn;
	6533	+ pRe->sIn.i = 0;
	6534	+ pRe->sIn.mx = (int)strlen(zIn);
	6535	+ zErr = re_subcompile_re(pRe);
	6536	+ if( zErr ){
	6537	+ re_free(pRe);
	6538	+ return zErr;
	6539	+ }
	6540	+ if( rePeek(pRe)=='$' && pRe->sIn.i+1>=pRe->sIn.mx ){
	6541	+ re_append(pRe, RE_OP_MATCH, RE_EOF);
	6542	+ re_append(pRe, RE_OP_ACCEPT, 0);
	6543	+ *ppRe = pRe;
	6544	+ }else if( pRe->sIn.i>=pRe->sIn.mx ){
	6545	+ re_append(pRe, RE_OP_ACCEPT, 0);
	6546	+ *ppRe = pRe;
	6547	+ }else{
	6548	+ re_free(pRe);
	6549	+ return "unrecognized character";
	6550	+ }
	6551	+
	6552	+ /* The following is a performance optimization. If the regex begins with
	6553	+ ** ".*" (if the input regex lacks an initial "^") and afterwards there are
	6554	+ ** one or more matching characters, enter those matching characters into
	6555	+ ** zInit[]. The re_match() routine can then search ahead in the input
	6556	+ ** string looking for the initial match without having to run the whole
	6557	+ ** regex engine over the string. Do not worry able trying to match
	6558	+ ** unicode characters beyond plane 0 - those are very rare and this is
	6559	+ ** just an optimization. */
	6560	+ if( pRe->aOp[0]==RE_OP_ANYSTAR && !noCase ){
	6561	+ for(j=0, i=1; j<sizeof(pRe->zInit)-2 && pRe->aOp[i]==RE_OP_MATCH; i++){
	6562	+ unsigned x = pRe->aArg[i];
	6563	+ if( x<=127 ){
	6564	+ pRe->zInit[j++] = (unsigned char)x;
	6565	+ }else if( x<=0xfff ){
	6566	+ pRe->zInit[j++] = (unsigned char)(0xc0 \| (x>>6));
	6567	+ pRe->zInit[j++] = 0x80 \| (x&0x3f);
	6568	+ }else if( x<=0xffff ){
	6569	+ pRe->zInit[j++] = (unsigned char)(0xd0 \| (x>>12));
	6570	+ pRe->zInit[j++] = 0x80 \| ((x>>6)&0x3f);
	6571	+ pRe->zInit[j++] = 0x80 \| (x&0x3f);
	6572	+ }else{
	6573	+ break;
	6574	+ }
	6575	+ }
	6576	+ if( j>0 && pRe->zInit[j-1]==0 ) j--;
	6577	+ pRe->nInit = j;
	6578	+ }
	6579	+ return pRe->zErr;
	6580	+}
	6581	+
	6582	+/*
	6583	+** Implementation of the regexp() SQL function. This function implements
	6584	+** the build-in REGEXP operator. The first argument to the function is the
	6585	+** pattern and the second argument is the string. So, the SQL statements:
	6586	+**
	6587	+** A REGEXP B
	6588	+**
	6589	+** is implemented as regexp(B,A).
	6590	+*/
	6591	+static void re_sql_func(
	6592	+ sqlite3_context *context,
	6593	+ int argc,
	6594	+ sqlite3_value **argv
	6595	+){
	6596	+ ReCompiled pRe; / Compiled regular expression */
	6597	+ const char zPattern; / The regular expression */
	6598	+ const unsigned char zStr;/ String being searched */
	6599	+ const char zErr; / Compile error message */
	6600	+ int setAux = 0; /* True to invoke sqlite3_set_auxdata() */
	6601	+
	6602	+ pRe = sqlite3_get_auxdata(context, 0);
	6603	+ if( pRe==0 ){
	6604	+ zPattern = (const char*)sqlite3_value_text(argv[0]);
	6605	+ if( zPattern==0 ) return;
	6606	+ zErr = re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
	6607	+ if( zErr ){
	6608	+ re_free(pRe);
	6609	+ sqlite3_result_error(context, zErr, -1);
	6610	+ return;
	6611	+ }
	6612	+ if( pRe==0 ){
	6613	+ sqlite3_result_error_nomem(context);
	6614	+ return;
	6615	+ }
	6616	+ setAux = 1;
	6617	+ }
	6618	+ zStr = (const unsigned char*)sqlite3_value_text(argv[1]);
	6619	+ if( zStr!=0 ){
	6620	+ sqlite3_result_int(context, re_match(pRe, zStr, -1));
	6621	+ }
	6622	+ if( setAux ){
	6623	+ sqlite3_set_auxdata(context, 0, pRe, (void()(void))re_free);
	6624	+ }
	6625	+}
	6626	+
	6627	+/*
	6628	+** Invoke this routine to register the regexp() function with the
	6629	+** SQLite database connection.
	6630	+*/
	6631	+#ifdef _WIN32
	6632	+
	6633	+#endif
	6634	+int sqlite3_regexp_init(
	6635	+ sqlite3 *db,
	6636	+ char **pzErrMsg,
	6637	+ const sqlite3_api_routines *pApi
	6638	+){
	6639	+ int rc = SQLITE_OK;
	6640	+ SQLITE_EXTENSION_INIT2(pApi);
	6641	+ rc = sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8\|SQLITE_INNOCUOUS,
	6642	+ 0, re_sql_func, 0, 0);
	6643	+ if( rc==SQLITE_OK ){
	6644	+ /* The regexpi(PATTERN,STRING) function is a case-insensitive version
	6645	+ ** of regexp(PATTERN,STRING). */
	6646	+ rc = sqlite3_create_function(db, "regexpi", 2, SQLITE_UTF8\|SQLITE_INNOCUOUS,
	6647	+ (void*)db, re_sql_func, 0, 0);
	6648	+ }
	6649	+ return rc;
	6650	+}
	6651	+
	6652	+/*********************** End ../ext/misc/regexp.c ******************/
5884	6653	#ifdef SQLITE_HAVE_ZLIB
5885	6654	/*********************** Begin ../ext/misc/zipfile.c ****************/
5886	6655	/*
5887	6656	** 2017-12-26
5888	6657	**
		@@ -14780,10 +15549,11 @@
14780	15549	sqlite3_fileio_init(p->db, 0, 0);
14781	15550	sqlite3_shathree_init(p->db, 0, 0);
14782	15551	sqlite3_completion_init(p->db, 0, 0);
14783	15552	sqlite3_uint_init(p->db, 0, 0);
14784	15553	sqlite3_decimal_init(p->db, 0, 0);
	15554	+ sqlite3_regexp_init(p->db, 0, 0);
14785	15555	sqlite3_ieee_init(p->db, 0, 0);
14786	15556	sqlite3_series_init(p->db, 0, 0);
14787	15557	#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
14788	15558	sqlite3_dbdata_init(p->db, 0, 0);
14789	15559	#endif
		@@ -17904,15 +18674,30 @@
17904	18674	raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
17905	18675	rc = 1;
17906	18676	sqlite3_free(zLike);
17907	18677	goto meta_command_exit;
17908	18678	}
17909		- }else if( zLike ){
17910		- zLike = sqlite3_mprintf("%z OR name LIKE %Q ESCAPE '\\'",
17911		- zLike, azArg[i]);
17912	18679	}else{
17913		- zLike = sqlite3_mprintf("name LIKE %Q ESCAPE '\\'", azArg[i]);
	18680	+ /* azArg[i] contains a LIKE pattern. This ".dump" request should
	18681	+ ** only dump data for tables for which either the table name matches
	18682	+ ** the LIKE pattern, or the table appears to be a shadow table of
	18683	+ ** a virtual table for which the name matches the LIKE pattern.
	18684	+ */
	18685	+ char *zExpr = sqlite3_mprintf(
	18686	+ "name LIKE %Q ESCAPE '\\' OR EXISTS ("
	18687	+ " SELECT 1 FROM sqlite_schema WHERE "
	18688	+ " name LIKE %Q ESCAPE '\\' AND"
	18689	+ " sql LIKE 'CREATE VIRTUAL TABLE%%' AND"
	18690	+ " substr(o.name, 1, length(name)+1) == (name\|\|'_')"
	18691	+ ")", azArg[i], azArg[i]
	18692	+ );
	18693	+
	18694	+ if( zLike ){
	18695	+ zLike = sqlite3_mprintf("%z OR %z", zLike, zExpr);
	18696	+ }else{
	18697	+ zLike = zExpr;
	18698	+ }
17914	18699	}
17915	18700	}
17916	18701
17917	18702	open_db(p, 0);
17918	18703
		@@ -17930,21 +18715,21 @@
17930	18715	** corrupt. */
17931	18716	sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
17932	18717	p->nErr = 0;
17933	18718	if( zLike==0 ) zLike = sqlite3_mprintf("true");
17934	18719	zSql = sqlite3_mprintf(
17935		- "SELECT name, type, sql FROM sqlite_schema "
	18720	+ "SELECT name, type, sql FROM sqlite_schema AS o "
17936	18721	"WHERE (%s) AND type=='table'"
17937	18722	" AND sql NOT NULL"
17938	18723	" ORDER BY tbl_name='sqlite_sequence', rowid",
17939	18724	zLike
17940	18725	);
17941	18726	run_schema_dump_query(p,zSql);
17942	18727	sqlite3_free(zSql);
17943	18728	if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
17944	18729	zSql = sqlite3_mprintf(
17945		- "SELECT sql FROM sqlite_schema "
	18730	+ "SELECT sql FROM sqlite_schema AS o "
17946	18731	"WHERE (%s) AND sql NOT NULL"
17947	18732	" AND type IN ('index','trigger','view')",
17948	18733	zLike
17949	18734	);
17950	18735	run_table_dump_query(p, zSql);
17951	18736

	--- src/shell.c
	+++ src/shell.c
	@@ -5879,10 +5879,779 @@
5879	#endif
5880	return rc;
5881	}
5882
5883	/*********************** End ../ext/misc/series.c ******************/

































































































































































































































































































































































































































































































































































































































































































































































































5884	#ifdef SQLITE_HAVE_ZLIB
5885	/*********************** Begin ../ext/misc/zipfile.c ****************/
5886	/*
5887	** 2017-12-26
5888	**
	@@ -14780,10 +15549,11 @@
14780	sqlite3_fileio_init(p->db, 0, 0);
14781	sqlite3_shathree_init(p->db, 0, 0);
14782	sqlite3_completion_init(p->db, 0, 0);
14783	sqlite3_uint_init(p->db, 0, 0);
14784	sqlite3_decimal_init(p->db, 0, 0);

14785	sqlite3_ieee_init(p->db, 0, 0);
14786	sqlite3_series_init(p->db, 0, 0);
14787	#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
14788	sqlite3_dbdata_init(p->db, 0, 0);
14789	#endif
	@@ -17904,15 +18674,30 @@
17904	raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
17905	rc = 1;
17906	sqlite3_free(zLike);
17907	goto meta_command_exit;
17908	}
17909	}else if( zLike ){
17910	zLike = sqlite3_mprintf("%z OR name LIKE %Q ESCAPE '\\'",
17911	zLike, azArg[i]);
17912	}else{
17913	zLike = sqlite3_mprintf("name LIKE %Q ESCAPE '\\'", azArg[i]);


















17914	}
17915	}
17916
17917	open_db(p, 0);
17918
	@@ -17930,21 +18715,21 @@
17930	** corrupt. */
17931	sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
17932	p->nErr = 0;
17933	if( zLike==0 ) zLike = sqlite3_mprintf("true");
17934	zSql = sqlite3_mprintf(
17935	"SELECT name, type, sql FROM sqlite_schema "
17936	"WHERE (%s) AND type=='table'"
17937	" AND sql NOT NULL"
17938	" ORDER BY tbl_name='sqlite_sequence', rowid",
17939	zLike
17940	);
17941	run_schema_dump_query(p,zSql);
17942	sqlite3_free(zSql);
17943	if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
17944	zSql = sqlite3_mprintf(
17945	"SELECT sql FROM sqlite_schema "
17946	"WHERE (%s) AND sql NOT NULL"
17947	" AND type IN ('index','trigger','view')",
17948	zLike
17949	);
17950	run_table_dump_query(p, zSql);
17951

	--- src/shell.c
	+++ src/shell.c
	@@ -5879,10 +5879,779 @@
5879	#endif
5880	return rc;
5881	}
5882
5883	/*********************** End ../ext/misc/series.c ******************/
5884	/*********************** Begin ../ext/misc/regexp.c ****************/
5885	/*
5886	** 2012-11-13
5887	**
5888	** The author disclaims copyright to this source code. In place of
5889	** a legal notice, here is a blessing:
5890	**
5891	** May you do good and not evil.
5892	** May you find forgiveness for yourself and forgive others.
5893	** May you share freely, never taking more than you give.
5894	**
5895	******************************************************************************
5896	**
5897	** The code in this file implements a compact but reasonably
5898	** efficient regular-expression matcher for posix extended regular
5899	** expressions against UTF8 text.
5900	**
5901	** This file is an SQLite extension. It registers a single function
5902	** named "regexp(A,B)" where A is the regular expression and B is the
5903	** string to be matched. By registering this function, SQLite will also
5904	** then implement the "B regexp A" operator. Note that with the function
5905	** the regular expression comes first, but with the operator it comes
5906	** second.
5907	**
5908	** The following regular expression syntax is supported:
5909	**
5910	** X* zero or more occurrences of X
5911	** X+ one or more occurrences of X
5912	** X? zero or one occurrences of X
5913	** X{p,q} between p and q occurrences of X
5914	** (X) match X
5915	** X\|Y X or Y
5916	** ^X X occurring at the beginning of the string
5917	** X$ X occurring at the end of the string
5918	** . Match any single character
5919	** \c Character c where c is one of \{}()[]\|*+?.
5920	** \c C-language escapes for c in afnrtv. ex: \t or \n
5921	** \uXXXX Where XXXX is exactly 4 hex digits, unicode value XXXX
5922	** \xXX Where XX is exactly 2 hex digits, unicode value XX
5923	** [abc] Any single character from the set abc
5924	** [^abc] Any single character not in the set abc
5925	** [a-z] Any single character in the range a-z
5926	** [^a-z] Any single character not in the range a-z
5927	** \b Word boundary
5928	** \w Word character. [A-Za-z0-9_]
5929	** \W Non-word character
5930	** \d Digit
5931	** \D Non-digit
5932	** \s Whitespace character
5933	** \S Non-whitespace character
5934	**
5935	** A nondeterministic finite automaton (NFA) is used for matching, so the
5936	** performance is bounded by O(N*M) where N is the size of the regular
5937	** expression and M is the size of the input string. The matcher never
5938	** exhibits exponential behavior. Note that the X{p,q} operator expands
5939	** to p copies of X following by q-p copies of X? and that the size of the
5940	** regular expression in the O(N*M) performance bound is computed after
5941	** this expansion.
5942	*/
5943	#include <string.h>
5944	#include <stdlib.h>
5945	/* #include "sqlite3ext.h" */
5946	SQLITE_EXTENSION_INIT1
5947
5948	/*
5949	** The following #defines change the names of some functions implemented in
5950	** this file to prevent name collisions with C-library functions of the
5951	** same name.
5952	*/
5953	#define re_match sqlite3re_match
5954	#define re_compile sqlite3re_compile
5955	#define re_free sqlite3re_free
5956
5957	/* The end-of-input character */
5958	#define RE_EOF 0 /* End of input */
5959
5960	/* The NFA is implemented as sequence of opcodes taken from the following
5961	** set. Each opcode has a single integer argument.
5962	*/
5963	#define RE_OP_MATCH 1 /* Match the one character in the argument */
5964	#define RE_OP_ANY 2 /* Match any one character. (Implements ".") */
5965	#define RE_OP_ANYSTAR 3 /* Special optimized version of .* */
5966	#define RE_OP_FORK 4 /* Continue to both next and opcode at iArg */
5967	#define RE_OP_GOTO 5 /* Jump to opcode at iArg */
5968	#define RE_OP_ACCEPT 6 /* Halt and indicate a successful match */
5969	#define RE_OP_CC_INC 7 /* Beginning of a [...] character class */
5970	#define RE_OP_CC_EXC 8 /* Beginning of a [^...] character class */
5971	#define RE_OP_CC_VALUE 9 /* Single value in a character class */
5972	#define RE_OP_CC_RANGE 10 /* Range of values in a character class */
5973	#define RE_OP_WORD 11 /* Perl word character [A-Za-z0-9_] */
5974	#define RE_OP_NOTWORD 12 /* Not a perl word character */
5975	#define RE_OP_DIGIT 13 /* digit: [0-9] */
5976	#define RE_OP_NOTDIGIT 14 /* Not a digit */
5977	#define RE_OP_SPACE 15 /* space: [ \t\n\r\v\f] */
5978	#define RE_OP_NOTSPACE 16 /* Not a digit */
5979	#define RE_OP_BOUNDARY 17 /* Boundary between word and non-word */
5980
5981	/* Each opcode is a "state" in the NFA */
5982	typedef unsigned short ReStateNumber;
5983
5984	/* Because this is an NFA and not a DFA, multiple states can be active at
5985	** once. An instance of the following object records all active states in
5986	** the NFA. The implementation is optimized for the common case where the
5987	** number of actives states is small.
5988	*/
5989	typedef struct ReStateSet {
5990	unsigned nState; /* Number of current states */
5991	ReStateNumber aState; / Current states */
5992	} ReStateSet;
5993
5994	/* An input string read one character at a time.
5995	*/
5996	typedef struct ReInput ReInput;
5997	struct ReInput {
5998	const unsigned char z; / All text */
5999	int i; /* Next byte to read */
6000	int mx; /* EOF when i>=mx */
6001	};
6002
6003	/* A compiled NFA (or an NFA that is in the process of being compiled) is
6004	** an instance of the following object.
6005	*/
6006	typedef struct ReCompiled ReCompiled;
6007	struct ReCompiled {
6008	ReInput sIn; /* Regular expression text */
6009	const char zErr; / Error message to return */
6010	char aOp; / Operators for the virtual machine */
6011	int aArg; / Arguments to each operator */
6012	unsigned (xNextChar)(ReInput); /* Next character function */
6013	unsigned char zInit[12]; /* Initial text to match */
6014	int nInit; /* Number of characters in zInit */
6015	unsigned nState; /* Number of entries in aOp[] and aArg[] */
6016	unsigned nAlloc; /* Slots allocated for aOp[] and aArg[] */
6017	};
6018
6019	/* Add a state to the given state set if it is not already there */
6020	static void re_add_state(ReStateSet *pSet, int newState){
6021	unsigned i;
6022	for(i=0; i<pSet->nState; i++) if( pSet->aState[i]==newState ) return;
6023	pSet->aState[pSet->nState++] = (ReStateNumber)newState;
6024	}
6025
6026	/* Extract the next unicode character from *pzIn and return it. Advance
6027	** *pzIn to the first byte past the end of the character returned. To
6028	** be clear: this routine converts utf8 to unicode. This routine is
6029	** optimized for the common case where the next character is a single byte.
6030	*/
6031	static unsigned re_next_char(ReInput *p){
6032	unsigned c;
6033	if( p->i>=p->mx ) return 0;
6034	c = p->z[p->i++];
6035	if( c>=0x80 ){
6036	if( (c&0xe0)==0xc0 && p->i<p->mx && (p->z[p->i]&0xc0)==0x80 ){
6037	c = (c&0x1f)<<6 \| (p->z[p->i++]&0x3f);
6038	if( c<0x80 ) c = 0xfffd;
6039	}else if( (c&0xf0)==0xe0 && p->i+1<p->mx && (p->z[p->i]&0xc0)==0x80
6040	&& (p->z[p->i+1]&0xc0)==0x80 ){
6041	c = (c&0x0f)<<12 \| ((p->z[p->i]&0x3f)<<6) \| (p->z[p->i+1]&0x3f);
6042	p->i += 2;
6043	if( c<=0x7ff \|\| (c>=0xd800 && c<=0xdfff) ) c = 0xfffd;
6044	}else if( (c&0xf8)==0xf0 && p->i+3<p->mx && (p->z[p->i]&0xc0)==0x80
6045	&& (p->z[p->i+1]&0xc0)==0x80 && (p->z[p->i+2]&0xc0)==0x80 ){
6046	c = (c&0x07)<<18 \| ((p->z[p->i]&0x3f)<<12) \| ((p->z[p->i+1]&0x3f)<<6)
6047	\| (p->z[p->i+2]&0x3f);
6048	p->i += 3;
6049	if( c<=0xffff \|\| c>0x10ffff ) c = 0xfffd;
6050	}else{
6051	c = 0xfffd;
6052	}
6053	}
6054	return c;
6055	}
6056	static unsigned re_next_char_nocase(ReInput *p){
6057	unsigned c = re_next_char(p);
6058	if( c>='A' && c<='Z' ) c += 'a' - 'A';
6059	return c;
6060	}
6061
6062	/* Return true if c is a perl "word" character: [A-Za-z0-9_] */
6063	static int re_word_char(int c){
6064	return (c>='0' && c<='9') \|\| (c>='a' && c<='z')
6065	\|\| (c>='A' && c<='Z') \|\| c=='_';
6066	}
6067
6068	/* Return true if c is a "digit" character: [0-9] */
6069	static int re_digit_char(int c){
6070	return (c>='0' && c<='9');
6071	}
6072
6073	/* Return true if c is a perl "space" character: [ \t\r\n\v\f] */
6074	static int re_space_char(int c){
6075	return c==' ' \|\| c=='\t' \|\| c=='\n' \|\| c=='\r' \|\| c=='\v' \|\| c=='\f';
6076	}
6077
6078	/* Run a compiled regular expression on the zero-terminated input
6079	** string zIn[]. Return true on a match and false if there is no match.
6080	*/
6081	static int re_match(ReCompiled pRe, const unsigned char zIn, int nIn){
6082	ReStateSet aStateSet[2], pThis, pNext;
6083	ReStateNumber aSpace[100];
6084	ReStateNumber *pToFree;
6085	unsigned int i = 0;
6086	unsigned int iSwap = 0;
6087	int c = RE_EOF+1;
6088	int cPrev = 0;
6089	int rc = 0;
6090	ReInput in;
6091
6092	in.z = zIn;
6093	in.i = 0;
6094	in.mx = nIn>=0 ? nIn : (int)strlen((char const*)zIn);
6095
6096	/* Look for the initial prefix match, if there is one. */
6097	if( pRe->nInit ){
6098	unsigned char x = pRe->zInit[0];
6099	while( in.i+pRe->nInit<=in.mx
6100	&& (zIn[in.i]!=x \|\|
6101	strncmp((const char)zIn+in.i, (const char)pRe->zInit, pRe->nInit)!=0)
6102	){
6103	in.i++;
6104	}
6105	if( in.i+pRe->nInit>in.mx ) return 0;
6106	}
6107
6108	if( pRe->nState<=(sizeof(aSpace)/(sizeof(aSpace[0])*2)) ){
6109	pToFree = 0;
6110	aStateSet[0].aState = aSpace;
6111	}else{
6112	pToFree = sqlite3_malloc64( sizeof(ReStateNumber)2pRe->nState );
6113	if( pToFree==0 ) return -1;
6114	aStateSet[0].aState = pToFree;
6115	}
6116	aStateSet[1].aState = &aStateSet[0].aState[pRe->nState];
6117	pNext = &aStateSet[1];
6118	pNext->nState = 0;
6119	re_add_state(pNext, 0);
6120	while( c!=RE_EOF && pNext->nState>0 ){
6121	cPrev = c;
6122	c = pRe->xNextChar(&in);
6123	pThis = pNext;
6124	pNext = &aStateSet[iSwap];
6125	iSwap = 1 - iSwap;
6126	pNext->nState = 0;
6127	for(i=0; i<pThis->nState; i++){
6128	int x = pThis->aState[i];
6129	switch( pRe->aOp[x] ){
6130	case RE_OP_MATCH: {
6131	if( pRe->aArg[x]==c ) re_add_state(pNext, x+1);
6132	break;
6133	}
6134	case RE_OP_ANY: {
6135	if( c!=0 ) re_add_state(pNext, x+1);
6136	break;
6137	}
6138	case RE_OP_WORD: {
6139	if( re_word_char(c) ) re_add_state(pNext, x+1);
6140	break;
6141	}
6142	case RE_OP_NOTWORD: {
6143	if( !re_word_char(c) ) re_add_state(pNext, x+1);
6144	break;
6145	}
6146	case RE_OP_DIGIT: {
6147	if( re_digit_char(c) ) re_add_state(pNext, x+1);
6148	break;
6149	}
6150	case RE_OP_NOTDIGIT: {
6151	if( !re_digit_char(c) ) re_add_state(pNext, x+1);
6152	break;
6153	}
6154	case RE_OP_SPACE: {
6155	if( re_space_char(c) ) re_add_state(pNext, x+1);
6156	break;
6157	}
6158	case RE_OP_NOTSPACE: {
6159	if( !re_space_char(c) ) re_add_state(pNext, x+1);
6160	break;
6161	}
6162	case RE_OP_BOUNDARY: {
6163	if( re_word_char(c)!=re_word_char(cPrev) ) re_add_state(pThis, x+1);
6164	break;
6165	}
6166	case RE_OP_ANYSTAR: {
6167	re_add_state(pNext, x);
6168	re_add_state(pThis, x+1);
6169	break;
6170	}
6171	case RE_OP_FORK: {
6172	re_add_state(pThis, x+pRe->aArg[x]);
6173	re_add_state(pThis, x+1);
6174	break;
6175	}
6176	case RE_OP_GOTO: {
6177	re_add_state(pThis, x+pRe->aArg[x]);
6178	break;
6179	}
6180	case RE_OP_ACCEPT: {
6181	rc = 1;
6182	goto re_match_end;
6183	}
6184	case RE_OP_CC_INC:
6185	case RE_OP_CC_EXC: {
6186	int j = 1;
6187	int n = pRe->aArg[x];
6188	int hit = 0;
6189	for(j=1; j>0 && j<n; j++){
6190	if( pRe->aOp[x+j]==RE_OP_CC_VALUE ){
6191	if( pRe->aArg[x+j]==c ){
6192	hit = 1;
6193	j = -1;
6194	}
6195	}else{
6196	if( pRe->aArg[x+j]<=c && pRe->aArg[x+j+1]>=c ){
6197	hit = 1;
6198	j = -1;
6199	}else{
6200	j++;
6201	}
6202	}
6203	}
6204	if( pRe->aOp[x]==RE_OP_CC_EXC ) hit = !hit;
6205	if( hit ) re_add_state(pNext, x+n);
6206	break;
6207	}
6208	}
6209	}
6210	}
6211	for(i=0; i<pNext->nState; i++){
6212	if( pRe->aOp[pNext->aState[i]]==RE_OP_ACCEPT ){ rc = 1; break; }
6213	}
6214	re_match_end:
6215	sqlite3_free(pToFree);
6216	return rc;
6217	}
6218
6219	/* Resize the opcode and argument arrays for an RE under construction.
6220	*/
6221	static int re_resize(ReCompiled *p, int N){
6222	char *aOp;
6223	int *aArg;
6224	aOp = sqlite3_realloc64(p->aOp, N*sizeof(p->aOp[0]));
6225	if( aOp==0 ) return 1;
6226	p->aOp = aOp;
6227	aArg = sqlite3_realloc64(p->aArg, N*sizeof(p->aArg[0]));
6228	if( aArg==0 ) return 1;
6229	p->aArg = aArg;
6230	p->nAlloc = N;
6231	return 0;
6232	}
6233
6234	/* Insert a new opcode and argument into an RE under construction. The
6235	** insertion point is just prior to existing opcode iBefore.
6236	*/
6237	static int re_insert(ReCompiled *p, int iBefore, int op, int arg){
6238	int i;
6239	if( p->nAlloc<=p->nState && re_resize(p, p->nAlloc*2) ) return 0;
6240	for(i=p->nState; i>iBefore; i--){
6241	p->aOp[i] = p->aOp[i-1];
6242	p->aArg[i] = p->aArg[i-1];
6243	}
6244	p->nState++;
6245	p->aOp[iBefore] = (char)op;
6246	p->aArg[iBefore] = arg;
6247	return iBefore;
6248	}
6249
6250	/* Append a new opcode and argument to the end of the RE under construction.
6251	*/
6252	static int re_append(ReCompiled *p, int op, int arg){
6253	return re_insert(p, p->nState, op, arg);
6254	}
6255
6256	/* Make a copy of N opcodes starting at iStart onto the end of the RE
6257	** under construction.
6258	*/
6259	static void re_copy(ReCompiled *p, int iStart, int N){
6260	if( p->nState+N>=p->nAlloc && re_resize(p, p->nAlloc*2+N) ) return;
6261	memcpy(&p->aOp[p->nState], &p->aOp[iStart], N*sizeof(p->aOp[0]));
6262	memcpy(&p->aArg[p->nState], &p->aArg[iStart], N*sizeof(p->aArg[0]));
6263	p->nState += N;
6264	}
6265
6266	/* Return true if c is a hexadecimal digit character: [0-9a-fA-F]
6267	** If c is a hex digit, also set pV = (pV)*16 + valueof(c). If
6268	** c is not a hex digit *pV is unchanged.
6269	*/
6270	static int re_hex(int c, int *pV){
6271	if( c>='0' && c<='9' ){
6272	c -= '0';
6273	}else if( c>='a' && c<='f' ){
6274	c -= 'a' - 10;
6275	}else if( c>='A' && c<='F' ){
6276	c -= 'A' - 10;
6277	}else{
6278	return 0;
6279	}
6280	pV = (pV)*16 + (c & 0xff);
6281	return 1;
6282	}
6283
6284	/* A backslash character has been seen, read the next character and
6285	** return its interpretation.
6286	*/
6287	static unsigned re_esc_char(ReCompiled *p){
6288	static const char zEsc[] = "afnrtv\\()*.+?[$^{\|}]";
6289	static const char zTrans[] = "\a\f\n\r\t\v";
6290	int i, v = 0;
6291	char c;
6292	if( p->sIn.i>=p->sIn.mx ) return 0;
6293	c = p->sIn.z[p->sIn.i];
6294	if( c=='u' && p->sIn.i+4<p->sIn.mx ){
6295	const unsigned char *zIn = p->sIn.z + p->sIn.i;
6296	if( re_hex(zIn[1],&v)
6297	&& re_hex(zIn[2],&v)
6298	&& re_hex(zIn[3],&v)
6299	&& re_hex(zIn[4],&v)
6300	){
6301	p->sIn.i += 5;
6302	return v;
6303	}
6304	}
6305	if( c=='x' && p->sIn.i+2<p->sIn.mx ){
6306	const unsigned char *zIn = p->sIn.z + p->sIn.i;
6307	if( re_hex(zIn[1],&v)
6308	&& re_hex(zIn[2],&v)
6309	){
6310	p->sIn.i += 3;
6311	return v;
6312	}
6313	}
6314	for(i=0; zEsc[i] && zEsc[i]!=c; i++){}
6315	if( zEsc[i] ){
6316	if( i<6 ) c = zTrans[i];
6317	p->sIn.i++;
6318	}else{
6319	p->zErr = "unknown \\ escape";
6320	}
6321	return c;
6322	}
6323
6324	/* Forward declaration */
6325	static const char re_subcompile_string(ReCompiled);
6326
6327	/* Peek at the next byte of input */
6328	static unsigned char rePeek(ReCompiled *p){
6329	return p->sIn.i<p->sIn.mx ? p->sIn.z[p->sIn.i] : 0;
6330	}
6331
6332	/* Compile RE text into a sequence of opcodes. Continue up to the
6333	** first unmatched ")" character, then return. If an error is found,
6334	** return a pointer to the error message string.
6335	*/
6336	static const char re_subcompile_re(ReCompiled p){
6337	const char *zErr;
6338	int iStart, iEnd, iGoto;
6339	iStart = p->nState;
6340	zErr = re_subcompile_string(p);
6341	if( zErr ) return zErr;
6342	while( rePeek(p)=='\|' ){
6343	iEnd = p->nState;
6344	re_insert(p, iStart, RE_OP_FORK, iEnd + 2 - iStart);
6345	iGoto = re_append(p, RE_OP_GOTO, 0);
6346	p->sIn.i++;
6347	zErr = re_subcompile_string(p);
6348	if( zErr ) return zErr;
6349	p->aArg[iGoto] = p->nState - iGoto;
6350	}
6351	return 0;
6352	}
6353
6354	/* Compile an element of regular expression text (anything that can be
6355	** an operand to the "\|" operator). Return NULL on success or a pointer
6356	** to the error message if there is a problem.
6357	*/
6358	static const char re_subcompile_string(ReCompiled p){
6359	int iPrev = -1;
6360	int iStart;
6361	unsigned c;
6362	const char *zErr;
6363	while( (c = p->xNextChar(&p->sIn))!=0 ){
6364	iStart = p->nState;
6365	switch( c ){
6366	case '\|':
6367	case '$':
6368	case ')': {
6369	p->sIn.i--;
6370	return 0;
6371	}
6372	case '(': {
6373	zErr = re_subcompile_re(p);
6374	if( zErr ) return zErr;
6375	if( rePeek(p)!=')' ) return "unmatched '('";
6376	p->sIn.i++;
6377	break;
6378	}
6379	case '.': {
6380	if( rePeek(p)=='*' ){
6381	re_append(p, RE_OP_ANYSTAR, 0);
6382	p->sIn.i++;
6383	}else{
6384	re_append(p, RE_OP_ANY, 0);
6385	}
6386	break;
6387	}
6388	case '*': {
6389	if( iPrev<0 ) return "'*' without operand";
6390	re_insert(p, iPrev, RE_OP_GOTO, p->nState - iPrev + 1);
6391	re_append(p, RE_OP_FORK, iPrev - p->nState + 1);
6392	break;
6393	}
6394	case '+': {
6395	if( iPrev<0 ) return "'+' without operand";
6396	re_append(p, RE_OP_FORK, iPrev - p->nState);
6397	break;
6398	}
6399	case '?': {
6400	if( iPrev<0 ) return "'?' without operand";
6401	re_insert(p, iPrev, RE_OP_FORK, p->nState - iPrev+1);
6402	break;
6403	}
6404	case '{': {
6405	int m = 0, n = 0;
6406	int sz, j;
6407	if( iPrev<0 ) return "'{m,n}' without operand";
6408	while( (c=rePeek(p))>='0' && c<='9' ){ m = m*10 + c - '0'; p->sIn.i++; }
6409	n = m;
6410	if( c==',' ){
6411	p->sIn.i++;
6412	n = 0;
6413	while( (c=rePeek(p))>='0' && c<='9' ){ n = n*10 + c-'0'; p->sIn.i++; }
6414	}
6415	if( c!='}' ) return "unmatched '{'";
6416	if( n>0 && n<m ) return "n less than m in '{m,n}'";
6417	p->sIn.i++;
6418	sz = p->nState - iPrev;
6419	if( m==0 ){
6420	if( n==0 ) return "both m and n are zero in '{m,n}'";
6421	re_insert(p, iPrev, RE_OP_FORK, sz+1);
6422	n--;
6423	}else{
6424	for(j=1; j<m; j++) re_copy(p, iPrev, sz);
6425	}
6426	for(j=m; j<n; j++){
6427	re_append(p, RE_OP_FORK, sz+1);
6428	re_copy(p, iPrev, sz);
6429	}
6430	if( n==0 && m>0 ){
6431	re_append(p, RE_OP_FORK, -sz);
6432	}
6433	break;
6434	}
6435	case '[': {
6436	int iFirst = p->nState;
6437	if( rePeek(p)=='^' ){
6438	re_append(p, RE_OP_CC_EXC, 0);
6439	p->sIn.i++;
6440	}else{
6441	re_append(p, RE_OP_CC_INC, 0);
6442	}
6443	while( (c = p->xNextChar(&p->sIn))!=0 ){
6444	if( c=='[' && rePeek(p)==':' ){
6445	return "POSIX character classes not supported";
6446	}
6447	if( c=='\\' ) c = re_esc_char(p);
6448	if( rePeek(p)=='-' ){
6449	re_append(p, RE_OP_CC_RANGE, c);
6450	p->sIn.i++;
6451	c = p->xNextChar(&p->sIn);
6452	if( c=='\\' ) c = re_esc_char(p);
6453	re_append(p, RE_OP_CC_RANGE, c);
6454	}else{
6455	re_append(p, RE_OP_CC_VALUE, c);
6456	}
6457	if( rePeek(p)==']' ){ p->sIn.i++; break; }
6458	}
6459	if( c==0 ) return "unclosed '['";
6460	p->aArg[iFirst] = p->nState - iFirst;
6461	break;
6462	}
6463	case '\\': {
6464	int specialOp = 0;
6465	switch( rePeek(p) ){
6466	case 'b': specialOp = RE_OP_BOUNDARY; break;
6467	case 'd': specialOp = RE_OP_DIGIT; break;
6468	case 'D': specialOp = RE_OP_NOTDIGIT; break;
6469	case 's': specialOp = RE_OP_SPACE; break;
6470	case 'S': specialOp = RE_OP_NOTSPACE; break;
6471	case 'w': specialOp = RE_OP_WORD; break;
6472	case 'W': specialOp = RE_OP_NOTWORD; break;
6473	}
6474	if( specialOp ){
6475	p->sIn.i++;
6476	re_append(p, specialOp, 0);
6477	}else{
6478	c = re_esc_char(p);
6479	re_append(p, RE_OP_MATCH, c);
6480	}
6481	break;
6482	}
6483	default: {
6484	re_append(p, RE_OP_MATCH, c);
6485	break;
6486	}
6487	}
6488	iPrev = iStart;
6489	}
6490	return 0;
6491	}
6492
6493	/* Free and reclaim all the memory used by a previously compiled
6494	** regular expression. Applications should invoke this routine once
6495	** for every call to re_compile() to avoid memory leaks.
6496	*/
6497	static void re_free(ReCompiled *pRe){
6498	if( pRe ){
6499	sqlite3_free(pRe->aOp);
6500	sqlite3_free(pRe->aArg);
6501	sqlite3_free(pRe);
6502	}
6503	}
6504
6505	/*
6506	** Compile a textual regular expression in zIn[] into a compiled regular
6507	** expression suitable for us by re_match() and return a pointer to the
6508	** compiled regular expression in *ppRe. Return NULL on success or an
6509	** error message if something goes wrong.
6510	*/
6511	static const char re_compile(ReCompiled ppRe, const char zIn, int noCase){
6512	ReCompiled *pRe;
6513	const char *zErr;
6514	int i, j;
6515
6516	*ppRe = 0;
6517	pRe = sqlite3_malloc( sizeof(*pRe) );
6518	if( pRe==0 ){
6519	return "out of memory";
6520	}
6521	memset(pRe, 0, sizeof(*pRe));
6522	pRe->xNextChar = noCase ? re_next_char_nocase : re_next_char;
6523	if( re_resize(pRe, 30) ){
6524	re_free(pRe);
6525	return "out of memory";
6526	}
6527	if( zIn[0]=='^' ){
6528	zIn++;
6529	}else{
6530	re_append(pRe, RE_OP_ANYSTAR, 0);
6531	}
6532	pRe->sIn.z = (unsigned char*)zIn;
6533	pRe->sIn.i = 0;
6534	pRe->sIn.mx = (int)strlen(zIn);
6535	zErr = re_subcompile_re(pRe);
6536	if( zErr ){
6537	re_free(pRe);
6538	return zErr;
6539	}
6540	if( rePeek(pRe)=='$' && pRe->sIn.i+1>=pRe->sIn.mx ){
6541	re_append(pRe, RE_OP_MATCH, RE_EOF);
6542	re_append(pRe, RE_OP_ACCEPT, 0);
6543	*ppRe = pRe;
6544	}else if( pRe->sIn.i>=pRe->sIn.mx ){
6545	re_append(pRe, RE_OP_ACCEPT, 0);
6546	*ppRe = pRe;
6547	}else{
6548	re_free(pRe);
6549	return "unrecognized character";
6550	}
6551
6552	/* The following is a performance optimization. If the regex begins with
6553	** ".*" (if the input regex lacks an initial "^") and afterwards there are
6554	** one or more matching characters, enter those matching characters into
6555	** zInit[]. The re_match() routine can then search ahead in the input
6556	** string looking for the initial match without having to run the whole
6557	** regex engine over the string. Do not worry able trying to match
6558	** unicode characters beyond plane 0 - those are very rare and this is
6559	** just an optimization. */
6560	if( pRe->aOp[0]==RE_OP_ANYSTAR && !noCase ){
6561	for(j=0, i=1; j<sizeof(pRe->zInit)-2 && pRe->aOp[i]==RE_OP_MATCH; i++){
6562	unsigned x = pRe->aArg[i];
6563	if( x<=127 ){
6564	pRe->zInit[j++] = (unsigned char)x;
6565	}else if( x<=0xfff ){
6566	pRe->zInit[j++] = (unsigned char)(0xc0 \| (x>>6));
6567	pRe->zInit[j++] = 0x80 \| (x&0x3f);
6568	}else if( x<=0xffff ){
6569	pRe->zInit[j++] = (unsigned char)(0xd0 \| (x>>12));
6570	pRe->zInit[j++] = 0x80 \| ((x>>6)&0x3f);
6571	pRe->zInit[j++] = 0x80 \| (x&0x3f);
6572	}else{
6573	break;
6574	}
6575	}
6576	if( j>0 && pRe->zInit[j-1]==0 ) j--;
6577	pRe->nInit = j;
6578	}
6579	return pRe->zErr;
6580	}
6581
6582	/*
6583	** Implementation of the regexp() SQL function. This function implements
6584	** the build-in REGEXP operator. The first argument to the function is the
6585	** pattern and the second argument is the string. So, the SQL statements:
6586	**
6587	** A REGEXP B
6588	**
6589	** is implemented as regexp(B,A).
6590	*/
6591	static void re_sql_func(
6592	sqlite3_context *context,
6593	int argc,
6594	sqlite3_value **argv
6595	){
6596	ReCompiled pRe; / Compiled regular expression */
6597	const char zPattern; / The regular expression */
6598	const unsigned char zStr;/ String being searched */
6599	const char zErr; / Compile error message */
6600	int setAux = 0; /* True to invoke sqlite3_set_auxdata() */
6601
6602	pRe = sqlite3_get_auxdata(context, 0);
6603	if( pRe==0 ){
6604	zPattern = (const char*)sqlite3_value_text(argv[0]);
6605	if( zPattern==0 ) return;
6606	zErr = re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
6607	if( zErr ){
6608	re_free(pRe);
6609	sqlite3_result_error(context, zErr, -1);
6610	return;
6611	}
6612	if( pRe==0 ){
6613	sqlite3_result_error_nomem(context);
6614	return;
6615	}
6616	setAux = 1;
6617	}
6618	zStr = (const unsigned char*)sqlite3_value_text(argv[1]);
6619	if( zStr!=0 ){
6620	sqlite3_result_int(context, re_match(pRe, zStr, -1));
6621	}
6622	if( setAux ){
6623	sqlite3_set_auxdata(context, 0, pRe, (void()(void))re_free);
6624	}
6625	}
6626
6627	/*
6628	** Invoke this routine to register the regexp() function with the
6629	** SQLite database connection.
6630	*/
6631	#ifdef _WIN32
6632
6633	#endif
6634	int sqlite3_regexp_init(
6635	sqlite3 *db,
6636	char **pzErrMsg,
6637	const sqlite3_api_routines *pApi
6638	){
6639	int rc = SQLITE_OK;
6640	SQLITE_EXTENSION_INIT2(pApi);
6641	rc = sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8\|SQLITE_INNOCUOUS,
6642	0, re_sql_func, 0, 0);
6643	if( rc==SQLITE_OK ){
6644	/* The regexpi(PATTERN,STRING) function is a case-insensitive version
6645	** of regexp(PATTERN,STRING). */
6646	rc = sqlite3_create_function(db, "regexpi", 2, SQLITE_UTF8\|SQLITE_INNOCUOUS,
6647	(void*)db, re_sql_func, 0, 0);
6648	}
6649	return rc;
6650	}
6651
6652	/*********************** End ../ext/misc/regexp.c ******************/
6653	#ifdef SQLITE_HAVE_ZLIB
6654	/*********************** Begin ../ext/misc/zipfile.c ****************/
6655	/*
6656	** 2017-12-26
6657	**
	@@ -14780,10 +15549,11 @@
15549	sqlite3_fileio_init(p->db, 0, 0);
15550	sqlite3_shathree_init(p->db, 0, 0);
15551	sqlite3_completion_init(p->db, 0, 0);
15552	sqlite3_uint_init(p->db, 0, 0);
15553	sqlite3_decimal_init(p->db, 0, 0);
15554	sqlite3_regexp_init(p->db, 0, 0);
15555	sqlite3_ieee_init(p->db, 0, 0);
15556	sqlite3_series_init(p->db, 0, 0);
15557	#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_ENABLE_DBPAGE_VTAB)
15558	sqlite3_dbdata_init(p->db, 0, 0);
15559	#endif
	@@ -17904,15 +18674,30 @@
18674	raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
18675	rc = 1;
18676	sqlite3_free(zLike);
18677	goto meta_command_exit;
18678	}



18679	}else{
18680	/* azArg[i] contains a LIKE pattern. This ".dump" request should
18681	** only dump data for tables for which either the table name matches
18682	** the LIKE pattern, or the table appears to be a shadow table of
18683	** a virtual table for which the name matches the LIKE pattern.
18684	*/
18685	char *zExpr = sqlite3_mprintf(
18686	"name LIKE %Q ESCAPE '\\' OR EXISTS ("
18687	" SELECT 1 FROM sqlite_schema WHERE "
18688	" name LIKE %Q ESCAPE '\\' AND"
18689	" sql LIKE 'CREATE VIRTUAL TABLE%%' AND"
18690	" substr(o.name, 1, length(name)+1) == (name\|\|'_')"
18691	")", azArg[i], azArg[i]
18692	);
18693
18694	if( zLike ){
18695	zLike = sqlite3_mprintf("%z OR %z", zLike, zExpr);
18696	}else{
18697	zLike = zExpr;
18698	}
18699	}
18700	}
18701
18702	open_db(p, 0);
18703
	@@ -17930,21 +18715,21 @@
18715	** corrupt. */
18716	sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
18717	p->nErr = 0;
18718	if( zLike==0 ) zLike = sqlite3_mprintf("true");
18719	zSql = sqlite3_mprintf(
18720	"SELECT name, type, sql FROM sqlite_schema AS o "
18721	"WHERE (%s) AND type=='table'"
18722	" AND sql NOT NULL"
18723	" ORDER BY tbl_name='sqlite_sequence', rowid",
18724	zLike
18725	);
18726	run_schema_dump_query(p,zSql);
18727	sqlite3_free(zSql);
18728	if( (p->shellFlgs & SHFLG_DumpDataOnly)==0 ){
18729	zSql = sqlite3_mprintf(
18730	"SELECT sql FROM sqlite_schema AS o "
18731	"WHERE (%s) AND sql NOT NULL"
18732	" AND type IN ('index','trigger','view')",
18733	zLike
18734	);
18735	run_table_dump_query(p, zSql);
18736

M src/sqlite3.c

+1834 -1652

		--- src/sqlite3.c
		+++ src/sqlite3.c
		@@ -81,12 +81,14 @@
81	81	"4_BYTE_ALIGNED_MALLOC",
82	82	#endif
83	83	#if SQLITE_64BIT_STATS
84	84	"64BIT_STATS",
85	85	#endif
86		-#if SQLITE_ALLOW_COVERING_INDEX_SCAN
87		- "ALLOW_COVERING_INDEX_SCAN",
	86	+#ifdef SQLITE_ALLOW_COVERING_INDEX_SCAN
	87	+# if SQLITE_ALLOW_COVERING_INDEX_SCAN != 1
	88	+ "ALLOW_COVERING_INDEX_SCAN=" CTIMEOPT_VAL(SQLITE_ALLOW_COVERING_INDEX_SCAN),
	89	+# endif
88	90	#endif
89	91	#if SQLITE_ALLOW_URI_AUTHORITY
90	92	"ALLOW_URI_AUTHORITY",
91	93	#endif
92	94	#ifdef SQLITE_BITMASK_TYPE
		@@ -144,12 +146,14 @@
144	146	"DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
145	147	#endif
146	148	#ifdef SQLITE_DEFAULT_LOOKASIDE
147	149	"DEFAULT_LOOKASIDE=" CTIMEOPT_VAL2(SQLITE_DEFAULT_LOOKASIDE),
148	150	#endif
149		-#if SQLITE_DEFAULT_MEMSTATUS
150		- "DEFAULT_MEMSTATUS",
	151	+#ifdef SQLITE_DEFAULT_MEMSTATUS
	152	+# if SQLITE_DEFAULT_MEMSTATUS != 1
	153	+ "DEFAULT_MEMSTATUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_MEMSTATUS),
	154	+# endif
151	155	#endif
152	156	#ifdef SQLITE_DEFAULT_MMAP_SIZE
153	157	"DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),
154	158	#endif
155	159	#ifdef SQLITE_DEFAULT_PAGE_SIZE
		@@ -219,11 +223,11 @@
219	223	"ENABLE_BATCH_ATOMIC_WRITE",
220	224	#endif
221	225	#if SQLITE_ENABLE_BYTECODE_VTAB
222	226	"ENABLE_BYTECODE_VTAB",
223	227	#endif
224		-#if SQLITE_ENABLE_CEROD
	228	+#ifdef SQLITE_ENABLE_CEROD
225	229	"ENABLE_CEROD=" CTIMEOPT_VAL(SQLITE_ENABLE_CEROD),
226	230	#endif
227	231	#if SQLITE_ENABLE_COLUMN_METADATA
228	232	"ENABLE_COLUMN_METADATA",
229	233	#endif
		@@ -233,22 +237,22 @@
233	237	#if SQLITE_ENABLE_COSTMULT
234	238	"ENABLE_COSTMULT",
235	239	#endif
236	240	#if SQLITE_ENABLE_CURSOR_HINTS
237	241	"ENABLE_CURSOR_HINTS",
	242	+#endif
	243	+#if SQLITE_ENABLE_DBPAGE_VTAB
	244	+ "ENABLE_DBPAGE_VTAB",
238	245	#endif
239	246	#if SQLITE_ENABLE_DBSTAT_VTAB
240	247	"ENABLE_DBSTAT_VTAB",
241	248	#endif
242	249	#if SQLITE_ENABLE_EXPENSIVE_ASSERT
243	250	"ENABLE_EXPENSIVE_ASSERT",
244	251	#endif
245		-#if SQLITE_ENABLE_FTS1
246		- "ENABLE_FTS1",
247		-#endif
248		-#if SQLITE_ENABLE_FTS2
249		- "ENABLE_FTS2",
	252	+#if SQLITE_ENABLE_EXPLAIN_COMMENTS
	253	+ "ENABLE_EXPLAIN_COMMENTS",
250	254	#endif
251	255	#if SQLITE_ENABLE_FTS3
252	256	"ENABLE_FTS3",
253	257	#endif
254	258	#if SQLITE_ENABLE_FTS3_PARENTHESIS
		@@ -302,10 +306,13 @@
302	306	#if SQLITE_ENABLE_NORMALIZE
303	307	"ENABLE_NORMALIZE",
304	308	#endif
305	309	#if SQLITE_ENABLE_NULL_TRIM
306	310	"ENABLE_NULL_TRIM",
	311	+#endif
	312	+#if SQLITE_ENABLE_OFFSET_SQL_FUNC
	313	+ "ENABLE_OFFSET_SQL_FUNC",
307	314	#endif
308	315	#if SQLITE_ENABLE_OVERSIZE_CELL_CHECK
309	316	"ENABLE_OVERSIZE_CELL_CHECK",
310	317	#endif
311	318	#if SQLITE_ENABLE_PREUPDATE_HOOK
		@@ -333,11 +340,11 @@
333	340	"ENABLE_SORTER_REFERENCES",
334	341	#endif
335	342	#if SQLITE_ENABLE_SQLLOG
336	343	"ENABLE_SQLLOG",
337	344	#endif
338		-#if defined(SQLITE_ENABLE_STAT4)
	345	+#if SQLITE_ENABLE_STAT4
339	346	"ENABLE_STAT4",
340	347	#endif
341	348	#if SQLITE_ENABLE_STMTVTAB
342	349	"ENABLE_STMTVTAB",
343	350	#endif
		@@ -387,12 +394,14 @@
387	394	"FTS5_NO_WITHOUT_ROWID",
388	395	#endif
389	396	#if HAVE_ISNAN \|\| SQLITE_HAVE_ISNAN
390	397	"HAVE_ISNAN",
391	398	#endif
392		-#if SQLITE_HOMEGROWN_RECURSIVE_MUTEX
393		- "HOMEGROWN_RECURSIVE_MUTEX",
	399	+#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
	400	+# if SQLITE_HOMEGROWN_RECURSIVE_MUTEX != 1
	401	+ "HOMEGROWN_RECURSIVE_MUTEX=" CTIMEOPT_VAL(SQLITE_HOMEGROWN_RECURSIVE_MUTEX),
	402	+# endif
394	403	#endif
395	404	#if SQLITE_IGNORE_AFP_LOCK_ERRORS
396	405	"IGNORE_AFP_LOCK_ERRORS",
397	406	#endif
398	407	#if SQLITE_IGNORE_FLOCK_LOCK_ERRORS
		@@ -486,13 +495,10 @@
486	495	"MMAP_READWRITE",
487	496	#endif
488	497	#if SQLITE_MUTEX_NOOP
489	498	"MUTEX_NOOP",
490	499	#endif
491		-#if SQLITE_MUTEX_NREF
492		- "MUTEX_NREF",
493		-#endif
494	500	#if SQLITE_MUTEX_OMIT
495	501	"MUTEX_OMIT",
496	502	#endif
497	503	#if SQLITE_MUTEX_PTHREADS
498	504	"MUTEX_PTHREADS",
		@@ -558,18 +564,21 @@
558	564	"OMIT_CONFLICT_CLAUSE",
559	565	#endif
560	566	#if SQLITE_OMIT_CTE
561	567	"OMIT_CTE",
562	568	#endif
563		-#if SQLITE_OMIT_DATETIME_FUNCS
	569	+#if defined(SQLITE_OMIT_DATETIME_FUNCS) \|\| defined(SQLITE_OMIT_FLOATING_POINT)
564	570	"OMIT_DATETIME_FUNCS",
565	571	#endif
566	572	#if SQLITE_OMIT_DECLTYPE
567	573	"OMIT_DECLTYPE",
568	574	#endif
569	575	#if SQLITE_OMIT_DEPRECATED
570	576	"OMIT_DEPRECATED",
	577	+#endif
	578	+#if SQLITE_OMIT_DESERIALIZE
	579	+ "OMIT_DESERIALIZE",
571	580	#endif
572	581	#if SQLITE_OMIT_DISKIO
573	582	"OMIT_DISKIO",
574	583	#endif
575	584	#if SQLITE_OMIT_EXPLAIN
		@@ -593,10 +602,13 @@
593	602	#if SQLITE_OMIT_INCRBLOB
594	603	"OMIT_INCRBLOB",
595	604	#endif
596	605	#if SQLITE_OMIT_INTEGRITY_CHECK
597	606	"OMIT_INTEGRITY_CHECK",
	607	+#endif
	608	+#if SQLITE_OMIT_INTROSPECTION_PRAGMAS
	609	+ "OMIT_INTROSPECTION_PRAGMAS",
598	610	#endif
599	611	#if SQLITE_OMIT_LIKE_OPTIMIZATION
600	612	"OMIT_LIKE_OPTIMIZATION",
601	613	#endif
602	614	#if SQLITE_OMIT_LOAD_EXTENSION
		@@ -657,12 +669,14 @@
657	669	"OMIT_TEMPDB",
658	670	#endif
659	671	#if SQLITE_OMIT_TEST_CONTROL
660	672	"OMIT_TEST_CONTROL",
661	673	#endif
662		-#if SQLITE_OMIT_TRACE
663		- "OMIT_TRACE",
	674	+#ifdef SQLITE_OMIT_TRACE
	675	+# if SQLITE_OMIT_TRACE != 1
	676	+ "OMIT_TRACE=" CTIMEOPT_VAL(SQLITE_OMIT_TRACE),
	677	+# endif
664	678	#endif
665	679	#if SQLITE_OMIT_TRIGGER
666	680	"OMIT_TRIGGER",
667	681	#endif
668	682	#if SQLITE_OMIT_TRUNCATE_OPTIMIZATION
		@@ -693,12 +707,14 @@
693	707	"PCACHE_SEPARATE_HEADER",
694	708	#endif
695	709	#if SQLITE_PERFORMANCE_TRACE
696	710	"PERFORMANCE_TRACE",
697	711	#endif
698		-#if SQLITE_POWERSAFE_OVERWRITE
699		- "POWERSAFE_OVERWRITE",
	712	+#ifdef SQLITE_POWERSAFE_OVERWRITE
	713	+# if SQLITE_POWERSAFE_OVERWRITE != 1
	714	+ "POWERSAFE_OVERWRITE=" CTIMEOPT_VAL(SQLITE_POWERSAFE_OVERWRITE),
	715	+# endif
700	716	#endif
701	717	#if SQLITE_PREFER_PROXY_LOCKING
702	718	"PREFER_PROXY_LOCKING",
703	719	#endif
704	720	#if SQLITE_PROXY_DEBUG
		@@ -729,11 +745,14 @@
729	745	"STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL),
730	746	#endif
731	747	#if SQLITE_SUBSTR_COMPATIBILITY
732	748	"SUBSTR_COMPATIBILITY",
733	749	#endif
734		-#if SQLITE_SYSTEM_MALLOC
	750	+#if (!defined(SQLITE_WIN32_MALLOC) \
	751	+ && !defined(SQLITE_ZERO_MALLOC) \
	752	+ && !defined(SQLITE_MEMDEBUG) \
	753	+ ) \|\| defined(SQLITE_SYSTEM_MALLOC)
735	754	"SYSTEM_MALLOC",
736	755	#endif
737	756	#if SQLITE_TCL
738	757	"TCL",
739	758	#endif
		@@ -1186,11 +1205,11 @@
1186	1205	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
1187	1206	** [sqlite_version()] and [sqlite_source_id()].
1188	1207	*/
1189	1208	#define SQLITE_VERSION "3.36.0"
1190	1209	#define SQLITE_VERSION_NUMBER 3036000
1191		-#define SQLITE_SOURCE_ID "2021-05-17 17:14:38 ace12a3912a4fdc2f0e741361ec705652a11b6f5e3548d54bd6f273671ba1e09"
	1210	+#define SQLITE_SOURCE_ID "2021-06-03 18:56:42 4a587c3492faa99490fd67ca1de9fceafcdc12d220f42817791923be258b73f1"
1192	1211
1193	1212	/*
1194	1213	** CAPI3REF: Run-Time Library Version Numbers
1195	1214	** KEYWORDS: sqlite3_version sqlite3_sourceid
1196	1215	**
		@@ -14310,12 +14329,13 @@
14310	14329	#define TK_VECTOR 176
14311	14330	#define TK_SELECT_COLUMN 177
14312	14331	#define TK_IF_NULL_ROW 178
14313	14332	#define TK_ASTERISK 179
14314	14333	#define TK_SPAN 180
14315		-#define TK_SPACE 181
14316		-#define TK_ILLEGAL 182
	14334	+#define TK_ERROR 181
	14335	+#define TK_SPACE 182
	14336	+#define TK_ILLEGAL 183
14317	14337
14318	14338	/************ End of parse.h *********************************************/
14319	14339	/************ Continuing where we left off in sqliteInt.h ****************/
14320	14340	#include <stdio.h>
14321	14341	#include <stdlib.h>
		@@ -16006,11 +16026,11 @@
16006	16026	/* 152 */ 0x10, 0x10, 0x00, 0x04, 0x1a, 0x00, 0x00, 0x00,\
16007	16027	/* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
16008	16028	/* 168 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
16009	16029	/* 176 */ 0x00, 0x00, 0x00, 0x00,}
16010	16030
16011		-/* The sqlite3P2Values() routine is able to run faster if it knows
	16031	+/* The resolve3P2Values() routine is able to run faster if it knows
16012	16032	** the value of the largest JUMP opcode. The smaller the maximum
16013	16033	** JUMP opcode the better, so the mkopcodeh.tcl script that
16014	16034	** generated this include file strives to group all JUMP opcodes
16015	16035	** together near the beginning of the list.
16016	16036	*/
		@@ -18511,10 +18531,11 @@
18511	18531	unsigned isCorrelated :1; /* True if sub-query is correlated */
18512	18532	unsigned viaCoroutine :1; /* Implemented as a co-routine */
18513	18533	unsigned isRecursive :1; /* True for recursive reference in WITH */
18514	18534	unsigned fromDDL :1; /* Comes from sqlite_schema */
18515	18535	unsigned isCte :1; /* This is a CTE */
	18536	+ unsigned notCte :1; /* This item may not match a CTE */
18516	18537	} fg;
18517	18538	int iCursor; /* The VDBE cursor number used to access this table */
18518	18539	Expr pOn; / The ON clause of a join */
18519	18540	IdList pUsing; / The USING clause of a join */
18520	18541	Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */
		@@ -19488,10 +19509,11 @@
19488	19509	** An instance of the With object represents a WITH clause containing
19489	19510	** one or more CTEs (common table expressions).
19490	19511	*/
19491	19512	struct With {
19492	19513	int nCte; /* Number of CTEs in the WITH clause */
	19514	+ int bView; /* Belongs to the outermost Select of a view */
19493	19515	With pOuter; / Containing WITH clause, or NULL */
19494	19516	Cte a[1]; /* For each CTE in the WITH clause.... */
19495	19517	};
19496	19518
19497	19519	/*
		@@ -19880,10 +19902,11 @@
19880	19902	SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3*);
19881	19903	SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3*,int);
19882	19904	SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3*);
19883	19905	SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
19884	19906	SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3,Table);
	19907	+SQLITE_PRIVATE void sqlite3GenerateColumnNames(Parse pParse, Select pSelect);
19885	19908	SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse,ExprList,i16,Column*);
19886	19909	SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(Parse,Table,Select*,char);
19887	19910	SQLITE_PRIVATE Table sqlite3ResultSetOfSelect(Parse,Select*,char);
19888	19911	SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *, int);
19889	19912	SQLITE_PRIVATE Index sqlite3PrimaryKeyIndex(Table);
		@@ -27891,11 +27914,10 @@
27891	27914	SQLITE_PRIVATE int sqlite3MallocInit(void){
27892	27915	int rc;
27893	27916	if( sqlite3GlobalConfig.m.xMalloc==0 ){
27894	27917	sqlite3MemSetDefault();
27895	27918	}
27896		- memset(&mem0, 0, sizeof(mem0));
27897	27919	mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
27898	27920	if( sqlite3GlobalConfig.pPage==0 \|\| sqlite3GlobalConfig.szPage<512
27899	27921	\|\| sqlite3GlobalConfig.nPage<=0 ){
27900	27922	sqlite3GlobalConfig.pPage = 0;
27901	27923	sqlite3GlobalConfig.szPage = 0;
		@@ -30588,10 +30610,18 @@
30588	30610	}
30589	30611	case TK_IF_NULL_ROW: {
30590	30612	sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable);
30591	30613	sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30592	30614	break;
	30615	+ }
	30616	+ case TK_ERROR: {
	30617	+ Expr tmp;
	30618	+ sqlite3TreeViewLine(pView, "ERROR");
	30619	+ tmp = *pExpr;
	30620	+ tmp.op = pExpr->op2;
	30621	+ sqlite3TreeViewExpr(pView, &tmp, 0);
	30622	+ break;
30593	30623	}
30594	30624	default: {
30595	30625	sqlite3TreeViewLine(pView, "op=%d", pExpr->op);
30596	30626	break;
30597	30627	}
		@@ -42058,10 +42088,26 @@
42058	42088	/* Register all VFSes defined in the aVfs[] array */
42059	42089	for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
42060	42090	sqlite3_vfs_register(&aVfs[i], i==0);
42061	42091	}
42062	42092	unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
	42093	+
	42094	+ /* Validate lock assumptions */
	42095	+ assert( SQLITE_SHM_NLOCK==8 ); /* Number of available locks */
	42096	+ assert( UNIX_SHM_BASE==120 ); /* Start of locking area */
	42097	+ /* Locks:
	42098	+ ** WRITE UNIX_SHM_BASE 120
	42099	+ ** CKPT UNIX_SHM_BASE+1 121
	42100	+ ** RECOVER UNIX_SHM_BASE+2 122
	42101	+ ** READ-0 UNIX_SHM_BASE+3 123
	42102	+ ** READ-1 UNIX_SHM_BASE+4 124
	42103	+ ** READ-2 UNIX_SHM_BASE+5 125
	42104	+ ** READ-3 UNIX_SHM_BASE+6 126
	42105	+ ** READ-4 UNIX_SHM_BASE+7 127
	42106	+ ** DMS UNIX_SHM_BASE+8 128
	42107	+ */
	42108	+ assert( UNIX_SHM_DMS==128 ); /* Byte offset of the deadman-switch */
42063	42109	return SQLITE_OK;
42064	42110	}
42065	42111
42066	42112	/*
42067	42113	** Shutdown the operating system interface.
		@@ -48523,16 +48569,16 @@
48523	48569	MemStore pStore; / The storage */
48524	48570	int eLock; /* Most recent lock against this file */
48525	48571	};
48526	48572
48527	48573	/*
48528		-** Global variables for holding the memdb files that are accessible
	48574	+** File-scope variables for holding the memdb files that are accessible
48529	48575	** to multiple database connections in separate threads.
48530	48576	**
48531	48577	** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object.
48532	48578	*/
48533		-struct MemFS {
	48579	+static struct MemFS {
48534	48580	int nMemStore; /* Number of shared MemStore objects */
48535	48581	MemStore *apMemStore; / Array of all shared MemStore objects */
48536	48582	} memdb_g;
48537	48583
48538	48584	/*
		@@ -74858,12 +74904,12 @@
74858	74904	if( rc ) goto cleardatabasepage_out;
74859	74905	}
74860	74906	if( !pPage->leaf ){
74861	74907	rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
74862	74908	if( rc ) goto cleardatabasepage_out;
74863		- }else if( pnChange ){
74864		- assert( pPage->intKey \|\| CORRUPT_DB );
	74909	+ }
	74910	+ if( pnChange ){
74865	74911	testcase( !pPage->intKey );
74866	74912	*pnChange += pPage->nCell;
74867	74913	}
74868	74914	if( freePageFlag ){
74869	74915	freePage(pPage, &rc);
		@@ -74884,13 +74930,12 @@
74884	74930	**
74885	74931	** This routine will fail with SQLITE_LOCKED if there are any open
74886	74932	** read cursors on the table. Open write cursors are moved to the
74887	74933	** root of the table.
74888	74934	**
74889		-** If pnChange is not NULL, then table iTable must be an intkey table. The
74890		-** integer value pointed to by pnChange is incremented by the number of
74891		-** entries in the table.
	74935	+** If pnChange is not NULL, then the integer value pointed to by pnChange
	74936	+** is incremented by the number of entries in the table.
74892	74937	*/
74893	74938	SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree p, int iTable, int pnChange){
74894	74939	int rc;
74895	74940	BtShared *pBt = p->pBt;
74896	74941	sqlite3BtreeEnter(p);
		@@ -86924,11 +86969,11 @@
86924	86969	printf(" <== R[%d]", (int)(p->pScopyFrom - &p[-iReg]));
86925	86970	}
86926	86971	printf("\n");
86927	86972	sqlite3VdbeCheckMemInvariants(p);
86928	86973	}
86929		-SQLITE_PRIVATE void sqlite3PrintMem(Mem *pMem){
	86974	+/*/ void sqlite3PrintMem(Mem pMem){
86930	86975	memTracePrint(pMem);
86931	86976	printf("\n");
86932	86977	fflush(stdout);
86933	86978	}
86934	86979	#endif
		@@ -88466,11 +88511,11 @@
88466	88511	pIn1 = &aMem[pOp->p1];
88467	88512	pIn3 = &aMem[pOp->p3];
88468	88513	flags1 = pIn1->flags;
88469	88514	flags3 = pIn3->flags;
88470	88515	if( (flags1 & flags3 & MEM_Int)!=0 ){
88471		- assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT );
	88516	+ assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT \|\| CORRUPT_DB );
88472	88517	/* Common case of comparison of two integers */
88473	88518	if( pIn3->u.i > pIn1->u.i ){
88474	88519	iCompare = +1;
88475	88520	if( sqlite3aGTb[pOp->opcode] ){
88476	88521	VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
		@@ -92663,15 +92708,14 @@
92663	92708	**
92664	92709	** The table being clear is in the main database file if P2==0. If
92665	92710	** P2==1 then the table to be clear is in the auxiliary database file
92666	92711	** that is used to store tables create using CREATE TEMPORARY TABLE.
92667	92712	**
92668		-** If the P3 value is non-zero, then the table referred to must be an
92669		-** intkey table (an SQL table, not an index). In this case the row change
92670		-** count is incremented by the number of rows in the table being cleared.
92671		-** If P3 is greater than zero, then the value stored in register P3 is
92672		-** also incremented by the number of rows in the table being cleared.
	92713	+** If the P3 value is non-zero, then the row change count is incremented
	92714	+** by the number of rows in the table being cleared. If P3 is greater
	92715	+** than zero, then the value stored in register P3 is also incremented
	92716	+** by the number of rows in the table being cleared.
92673	92717	**
92674	92718	** See also: Destroy
92675	92719	*/
92676	92720	case OP_Clear: {
92677	92721	int nChange;
		@@ -92678,13 +92722,11 @@
92678	92722
92679	92723	sqlite3VdbeIncrWriteCounter(p, 0);
92680	92724	nChange = 0;
92681	92725	assert( p->readOnly==0 );
92682	92726	assert( DbMaskTest(p->btreeMask, pOp->p2) );
92683		- rc = sqlite3BtreeClearTable(
92684		- db->aDb[pOp->p2].pBt, (u32)pOp->p1, (pOp->p3 ? &nChange : 0)
92685		- );
	92727	+ rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, (u32)pOp->p1, &nChange);
92686	92728	if( pOp->p3 ){
92687	92729	p->nChange += nChange;
92688	92730	if( pOp->p3>0 ){
92689	92731	assert( memIsValid(&aMem[pOp->p3]) );
92690	92732	memAboutToChange(p, &aMem[pOp->p3]);
		@@ -93668,10 +93710,11 @@
93668	93710
93669	93711	pBt = db->aDb[pOp->p1].pBt;
93670	93712	pPager = sqlite3BtreePager(pBt);
93671	93713	eOld = sqlite3PagerGetJournalMode(pPager);
93672	93714	if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;
	93715	+ assert( sqlite3BtreeHoldsMutex(pBt) );
93673	93716	if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
93674	93717
93675	93718	#ifndef SQLITE_OMIT_WAL
93676	93719	zFilename = sqlite3PagerFilename(pPager, 1);
93677	93720
		@@ -98688,30 +98731,32 @@
98688	98731	/*
98689	98732	** Truncate the in-memory file.
98690	98733	*/
98691	98734	static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
98692	98735	MemJournal p = (MemJournal )pJfd;
98693		- FileChunk *pIter = 0;
98694		-
98695		- if( size==0 ){
98696		- memjrnlFreeChunks(p->pFirst);
98697		- p->pFirst = 0;
98698		- }else{
98699		- i64 iOff = p->nChunkSize;
98700		- for(pIter=p->pFirst; ALWAYS(pIter) && iOff<=size; pIter=pIter->pNext){
98701		- iOff += p->nChunkSize;
98702		- }
98703		- if( ALWAYS(pIter) ){
98704		- memjrnlFreeChunks(pIter->pNext);
98705		- pIter->pNext = 0;
98706		- }
98707		- }
98708		-
98709		- p->endpoint.pChunk = pIter;
98710		- p->endpoint.iOffset = size;
98711		- p->readpoint.pChunk = 0;
98712		- p->readpoint.iOffset = 0;
	98736	+ assert( p->endpoint.pChunk==0 \|\| p->endpoint.pChunk->pNext==0 );
	98737	+ if( size<p->endpoint.iOffset ){
	98738	+ FileChunk *pIter = 0;
	98739	+ if( size==0 ){
	98740	+ memjrnlFreeChunks(p->pFirst);
	98741	+ p->pFirst = 0;
	98742	+ }else{
	98743	+ i64 iOff = p->nChunkSize;
	98744	+ for(pIter=p->pFirst; ALWAYS(pIter) && iOff<=size; pIter=pIter->pNext){
	98745	+ iOff += p->nChunkSize;
	98746	+ }
	98747	+ if( ALWAYS(pIter) ){
	98748	+ memjrnlFreeChunks(pIter->pNext);
	98749	+ pIter->pNext = 0;
	98750	+ }
	98751	+ }
	98752	+
	98753	+ p->endpoint.pChunk = pIter;
	98754	+ p->endpoint.iOffset = size;
	98755	+ p->readpoint.pChunk = 0;
	98756	+ p->readpoint.iOffset = 0;
	98757	+ }
98713	98758	return SQLITE_OK;
98714	98759	}
98715	98760
98716	98761	/*
98717	98762	** Close the file.
		@@ -100390,11 +100435,11 @@
100390	100435	nc.uNC.pEList = pEList;
100391	100436	nc.ncFlags = NC_AllowAgg\|NC_UEList\|NC_NoSelect;
100392	100437	nc.nNcErr = 0;
100393	100438	db = pParse->db;
100394	100439	savedSuppErr = db->suppressErr;
100395		- if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1;
	100440	+ db->suppressErr = 1;
100396	100441	rc = sqlite3ResolveExprNames(&nc, pE);
100397	100442	db->suppressErr = savedSuppErr;
100398	100443	if( rc ) return 0;
100399	100444
100400	100445	/* Try to match the ORDER BY expression against an expression
		@@ -100489,33 +100534,28 @@
100489	100534	** expression, resolving any symbols in it, and then comparing
100490	100535	** it against each expression returned by the SELECT statement.
100491	100536	** Once the comparisons are finished, the duplicate expression
100492	100537	** is deleted.
100493	100538	**
100494		- ** Or, if this is running as part of an ALTER TABLE operation,
100495		- ** resolve the symbols in the actual expression, not a duplicate.
100496		- ** And, if one of the comparisons is successful, leave the expression
100497		- ** as is instead of transforming it to an integer as in the usual
100498		- ** case. This allows the code in alter.c to modify column
100499		- ** refererences within the ORDER BY expression as required. */
100500		- if( IN_RENAME_OBJECT ){
100501		- pDup = pE;
100502		- }else{
100503		- pDup = sqlite3ExprDup(db, pE, 0);
100504		- }
	100539	+ ** If this is running as part of an ALTER TABLE operation and
	100540	+ ** the symbols resolve successfully, also resolve the symbols in the
	100541	+ ** actual expression. This allows the code in alter.c to modify
	100542	+ ** column references within the ORDER BY expression as required. */
	100543	+ pDup = sqlite3ExprDup(db, pE, 0);
100505	100544	if( !db->mallocFailed ){
100506	100545	assert(pDup);
100507	100546	iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
	100547	+ if( IN_RENAME_OBJECT && iCol>0 ){
	100548	+ resolveOrderByTermToExprList(pParse, pSelect, pE);
	100549	+ }
100508	100550	}
100509		- if( !IN_RENAME_OBJECT ){
100510		- sqlite3ExprDelete(db, pDup);
100511		- }
	100551	+ sqlite3ExprDelete(db, pDup);
100512	100552	}
100513	100553	}
100514	100554	if( iCol>0 ){
100515	100555	/* Convert the ORDER BY term into an integer column number iCol,
100516		- ** taking care to preserve the COLLATE clause if it exists */
	100556	+ ** taking care to preserve the COLLATE clause if it exists. */
100517	100557	if( !IN_RENAME_OBJECT ){
100518	100558	Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
100519	100559	if( pNew==0 ) return 1;
100520	100560	pNew->flags \|= EP_IntValue;
100521	100561	pNew->u.iValue = iCol;
		@@ -101595,11 +101635,11 @@
101595	101635	** just the expression for the i-th term of the result set, and may
101596	101636	** not be ready for evaluation because the table cursor has not yet
101597	101637	** been positioned.
101598	101638	*/
101599	101639	SQLITE_PRIVATE Expr sqlite3VectorFieldSubexpr(Expr pVector, int i){
101600		- assert( i<sqlite3ExprVectorSize(pVector) );
	101640	+ assert( i<sqlite3ExprVectorSize(pVector) \|\| pVector->op==TK_ERROR );
101601	101641	if( sqlite3ExprIsVector(pVector) ){
101602	101642	assert( pVector->op2==0 \|\| pVector->op==TK_REGISTER );
101603	101643	if( pVector->op==TK_SELECT \|\| pVector->op2==TK_SELECT ){
101604	101644	return pVector->x.pSelect->pEList->a[i].pExpr;
101605	101645	}else{
		@@ -101711,21 +101751,24 @@
101711	101751	int regSelect, /* First in array of registers */
101712	101752	Expr *ppExpr, / OUT: Expression element */
101713	101753	int pRegFree / OUT: Temp register to free */
101714	101754	){
101715	101755	u8 op = pVector->op;
101716		- assert( op==TK_VECTOR \|\| op==TK_REGISTER \|\| op==TK_SELECT );
	101756	+ assert( op==TK_VECTOR \|\| op==TK_REGISTER \|\| op==TK_SELECT \|\| op==TK_ERROR );
101717	101757	if( op==TK_REGISTER ){
101718	101758	*ppExpr = sqlite3VectorFieldSubexpr(pVector, iField);
101719	101759	return pVector->iTable+iField;
101720	101760	}
101721	101761	if( op==TK_SELECT ){
101722	101762	*ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
101723	101763	return regSelect+iField;
101724	101764	}
101725		- *ppExpr = pVector->x.pList->a[iField].pExpr;
101726		- return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree);
	101765	+ if( op==TK_VECTOR ){
	101766	+ *ppExpr = pVector->x.pList->a[iField].pExpr;
	101767	+ return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree);
	101768	+ }
	101769	+ return 0;
101727	101770	}
101728	101771
101729	101772	/*
101730	101773	** Expression pExpr is a comparison between two vector values. Compute
101731	101774	** the result of the comparison (1, 0, or NULL) and write that
		@@ -102658,11 +102701,12 @@
102658	102701	&& pOldExpr->op==TK_SELECT_COLUMN
102659	102702	&& (pNewExpr = pItem->pExpr)!=0
102660	102703	){
102661	102704	assert( pNewExpr->iColumn==0 \|\| i>0 );
102662	102705	if( pNewExpr->iColumn==0 ){
102663		- assert( pOldExpr->pLeft==pOldExpr->pRight );
	102706	+ assert( pOldExpr->pLeft==pOldExpr->pRight
	102707	+ \|\| ExprHasProperty(pOldExpr->pLeft, EP_Subquery) );
102664	102708	pPriorSelectCol = pNewExpr->pLeft = pNewExpr->pRight;
102665	102709	}else{
102666	102710	assert( i>0 );
102667	102711	assert( pItem[-1].pExpr!=0 );
102668	102712	assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 );
		@@ -104131,23 +104175,27 @@
104131	104175	addrOnce?"":"CORRELATED ", pSelect->selId
104132	104176	));
104133	104177	/* If the LHS and RHS of the IN operator do not match, that
104134	104178	** error will have been caught long before we reach this point. */
104135	104179	if( ALWAYS(pEList->nExpr==nVal) ){
	104180	+ Select *pCopy;
104136	104181	SelectDest dest;
104137	104182	int i;
	104183	+ int rc;
104138	104184	sqlite3SelectDestInit(&dest, SRT_Set, iTab);
104139	104185	dest.zAffSdst = exprINAffinity(pParse, pExpr);
104140	104186	pSelect->iLimit = 0;
104141	104187	testcase( pSelect->selFlags & SF_Distinct );
104142	104188	testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
104143		- if( sqlite3Select(pParse, pSelect, &dest) ){
104144		- sqlite3DbFree(pParse->db, dest.zAffSdst);
	104189	+ pCopy = sqlite3SelectDup(pParse->db, pSelect, 0);
	104190	+ rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest);
	104191	+ sqlite3SelectDelete(pParse->db, pCopy);
	104192	+ sqlite3DbFree(pParse->db, dest.zAffSdst);
	104193	+ if( rc ){
104145	104194	sqlite3KeyInfoUnref(pKeyInfo);
104146	104195	return;
104147	104196	}
104148		- sqlite3DbFree(pParse->db, dest.zAffSdst);
104149	104197	assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
104150	104198	assert( pEList!=0 );
104151	104199	assert( pEList->nExpr>0 );
104152	104200	assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
104153	104201	for(i=0; i<nVal; i++){
		@@ -104242,15 +104290,33 @@
104242	104290	int nReg; /* Registers to allocate */
104243	104291	Expr pLimit; / New limit expression */
104244	104292
104245	104293	Vdbe *v = pParse->pVdbe;
104246	104294	assert( v!=0 );
	104295	+ if( pParse->nErr ) return 0;
104247	104296	testcase( pExpr->op==TK_EXISTS );
104248	104297	testcase( pExpr->op==TK_SELECT );
104249	104298	assert( pExpr->op==TK_EXISTS \|\| pExpr->op==TK_SELECT );
104250	104299	assert( ExprHasProperty(pExpr, EP_xIsSelect) );
104251	104300	pSel = pExpr->x.pSelect;
	104301	+
	104302	+ /* If this routine has already been coded, then invoke it as a
	104303	+ ** subroutine. */
	104304	+ if( ExprHasProperty(pExpr, EP_Subrtn) ){
	104305	+ ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId));
	104306	+ sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
	104307	+ pExpr->y.sub.iAddr);
	104308	+ return pExpr->iTable;
	104309	+ }
	104310	+
	104311	+ /* Begin coding the subroutine */
	104312	+ ExprSetProperty(pExpr, EP_Subrtn);
	104313	+ pExpr->y.sub.regReturn = ++pParse->nMem;
	104314	+ pExpr->y.sub.iAddr =
	104315	+ sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
	104316	+ VdbeComment((v, "return address"));
	104317	+
104252	104318
104253	104319	/* The evaluation of the EXISTS/SELECT must be repeated every time it
104254	104320	** is encountered if any of the following is true:
104255	104321	**
104256	104322	** * The right-hand side is a correlated subquery
		@@ -104259,26 +104325,10 @@
104259	104325	**
104260	104326	** If all of the above are false, then we can run this code just once
104261	104327	** save the results, and reuse the same result on subsequent invocations.
104262	104328	*/
104263	104329	if( !ExprHasProperty(pExpr, EP_VarSelect) ){
104264		- /* If this routine has already been coded, then invoke it as a
104265		- ** subroutine. */
104266		- if( ExprHasProperty(pExpr, EP_Subrtn) ){
104267		- ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId));
104268		- sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
104269		- pExpr->y.sub.iAddr);
104270		- return pExpr->iTable;
104271		- }
104272		-
104273		- /* Begin coding the subroutine */
104274		- ExprSetProperty(pExpr, EP_Subrtn);
104275		- pExpr->y.sub.regReturn = ++pParse->nMem;
104276		- pExpr->y.sub.iAddr =
104277		- sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
104278		- VdbeComment((v, "return address"));
104279		-
104280	104330	addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
104281	104331	}
104282	104332
104283	104333	/* For a SELECT, generate code to put the values for all columns of
104284	104334	** the first row into an array of registers and return the index of
		@@ -104323,23 +104373,26 @@
104323	104373	pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1");
104324	104374	pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0);
104325	104375	}
104326	104376	pSel->iLimit = 0;
104327	104377	if( sqlite3Select(pParse, pSel, &dest) ){
	104378	+ if( pParse->nErr ){
	104379	+ pExpr->op2 = pExpr->op;
	104380	+ pExpr->op = TK_ERROR;
	104381	+ }
104328	104382	return 0;
104329	104383	}
104330	104384	pExpr->iTable = rReg = dest.iSDParm;
104331	104385	ExprSetVVAProperty(pExpr, EP_NoReduce);
104332	104386	if( addrOnce ){
104333	104387	sqlite3VdbeJumpHere(v, addrOnce);
104334		-
104335		- /* Subroutine return */
104336		- sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
104337		- sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
104338		- sqlite3ClearTempRegCache(pParse);
104339	104388	}
104340	104389
	104390	+ /* Subroutine return */
	104391	+ sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
	104392	+ sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
	104393	+ sqlite3ClearTempRegCache(pParse);
104341	104394	return rReg;
104342	104395	}
104343	104396	#endif /* SQLITE_OMIT_SUBQUERY */
104344	104397
104345	104398	#ifndef SQLITE_OMIT_SUBQUERY
		@@ -105166,11 +105219,11 @@
105166	105219	default: {
105167	105220	/* Make NULL the default case so that if a bug causes an illegal
105168	105221	** Expr node to be passed into this function, it will be handled
105169	105222	** sanely and not crash. But keep the assert() to bring the problem
105170	105223	** to the attention of the developers. */
105171		- assert( op==TK_NULL \|\| pParse->db->mallocFailed );
	105224	+ assert( op==TK_NULL \|\| op==TK_ERROR \|\| pParse->db->mallocFailed );
105172	105225	sqlite3VdbeAddOp2(v, OP_Null, 0, target);
105173	105226	return target;
105174	105227	}
105175	105228	#ifndef SQLITE_OMIT_BLOB_LITERAL
105176	105229	case TK_BLOB: {
		@@ -105509,11 +105562,12 @@
105509	105562	case TK_SELECT_COLUMN: {
105510	105563	int n;
105511	105564	if( pExpr->pLeft->iTable==0 ){
105512	105565	pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft);
105513	105566	}
105514		- assert( pExpr->iTable==0 \|\| pExpr->pLeft->op==TK_SELECT );
	105567	+ assert( pExpr->iTable==0 \|\| pExpr->pLeft->op==TK_SELECT
	105568	+ \|\| pExpr->pLeft->op==TK_ERROR );
105515	105569	if( pExpr->iTable!=0
105516	105570	&& pExpr->iTable!=(n = sqlite3ExprVectorSize(pExpr->pLeft))
105517	105571	){
105518	105572	sqlite3ErrorMsg(pParse, "%d columns assigned %d values",
105519	105573	pExpr->iTable, n);
		@@ -107141,10 +107195,11 @@
107141	107195	/* Check to see if pExpr is a duplicate of another aggregate
107142	107196	** function that is already in the pAggInfo structure
107143	107197	*/
107144	107198	struct AggInfo_func *pItem = pAggInfo->aFunc;
107145	107199	for(i=0; i<pAggInfo->nFunc; i++, pItem++){
	107200	+ if( pItem->pFExpr==pExpr ) break;
107146	107201	if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
107147	107202	break;
107148	107203	}
107149	107204	}
107150	107205	if( i>=pAggInfo->nFunc ){
		@@ -108229,11 +108284,11 @@
108229	108284	Parse *pParse,
108230	108285	struct RenameCtx *pCtx,
108231	108286	void *pPtr
108232	108287	){
108233	108288	RenameToken **pp;
108234		- if( NEVER(pPtr==0) ){
	108289	+ if( pPtr==0 ){
108235	108290	return 0;
108236	108291	}
108237	108292	for(pp=&pParse->pRename; (pp); pp=&(pp)->pNext){
108238	108293	if( (*pp)->p==pPtr ){
108239	108294	RenameToken pToken = pp;
		@@ -111886,18 +111941,21 @@
111886	111941	SrcList *pList = pSelect->pSrc;
111887	111942
111888	111943	if( NEVER(pList==0) ) return WRC_Continue;
111889	111944	for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
111890	111945	if( pFix->bTemp==0 ){
111891		- if( pItem->zDatabase && iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
111892		- sqlite3ErrorMsg(pFix->pParse,
111893		- "%s %T cannot reference objects in database %s",
111894		- pFix->zType, pFix->pName, pItem->zDatabase);
111895		- return WRC_Abort;
111896		- }
111897		- sqlite3DbFree(db, pItem->zDatabase);
111898		- pItem->zDatabase = 0;
	111946	+ if( pItem->zDatabase ){
	111947	+ if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
	111948	+ sqlite3ErrorMsg(pFix->pParse,
	111949	+ "%s %T cannot reference objects in database %s",
	111950	+ pFix->zType, pFix->pName, pItem->zDatabase);
	111951	+ return WRC_Abort;
	111952	+ }
	111953	+ sqlite3DbFree(db, pItem->zDatabase);
	111954	+ pItem->zDatabase = 0;
	111955	+ pItem->fg.notCte = 1;
	111956	+ }
111899	111957	pItem->pSchema = pFix->pSchema;
111900	111958	pItem->fg.fromDDL = 1;
111901	111959	}
111902	111960	#if !defined(SQLITE_OMIT_VIEW) \|\| !defined(SQLITE_OMIT_TRIGGER)
111903	111961	if( sqlite3WalkExpr(&pFix->w, pList->a[i].pOn) ) return WRC_Abort;
		@@ -113178,11 +113236,11 @@
113178	113236	if( iDb<0 ){
113179	113237	sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
113180	113238	return -1;
113181	113239	}
113182	113240	}else{
113183		- assert( db->init.iDb==0 \|\| db->init.busy \|\| IN_RENAME_OBJECT
	113241	+ assert( db->init.iDb==0 \|\| db->init.busy \|\| IN_SPECIAL_PARSE
113184	113242	\|\| (db->mDbFlags & DBFLAG_Vacuum)!=0);
113185	113243	iDb = db->init.iDb;
113186	113244	*pUnqual = pName1;
113187	113245	}
113188	113246	return iDb;
		@@ -113360,10 +113418,11 @@
113360	113418	static void sqlite3ForceNotReadOnly(Parse *pParse){
113361	113419	int iReg = ++pParse->nMem;
113362	113420	Vdbe *v = sqlite3GetVdbe(pParse);
113363	113421	if( v ){
113364	113422	sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY);
	113423	+ sqlite3VdbeUsesBtree(v, 0);
113365	113424	}
113366	113425	}
113367	113426
113368	113427	/*
113369	113428	** Begin constructing a new table representation in memory. This is
		@@ -118643,10 +118702,13 @@
118643	118702	pTab->zName, P4_STATIC);
118644	118703	}
118645	118704	for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
118646	118705	assert( pIdx->pSchema==pTab->pSchema );
118647	118706	sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
	118707	+ if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
	118708	+ sqlite3VdbeChangeP3(v, -1, memCnt ? memCnt : -1);
	118709	+ }
118648	118710	}
118649	118711	}else
118650	118712	#endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
118651	118713	{
118652	118714	u16 wcf = WHERE_ONEPASS_DESIRED\|WHERE_DUPLICATES_OK;
		@@ -133883,11 +133945,11 @@
133883	133945	**
133884	133946	** full=ON, short=ANY: If the result refers directly to a table column,
133885	133947	** then the result column name with the table name
133886	133948	** prefix, ex: TABLE.COLUMN. Otherwise use zSpan.
133887	133949	*/
133888		-static void generateColumnNames(
	133950	+SQLITE_PRIVATE void sqlite3GenerateColumnNames(
133889	133951	Parse pParse, / Parser context */
133890	133952	Select pSelect / Generate column names for this SELECT statement */
133891	133953	){
133892	133954	Vdbe *v = pParse->pVdbe;
133893	133955	int i;
		@@ -133973,11 +134035,11 @@
133973	134035	** That is the only documented guarantee. However, countless applications
133974	134036	** developed over the years have made baseless assumptions about column names
133975	134037	** and will break if those assumptions changes. Hence, use extreme caution
133976	134038	** when modifying this routine to avoid breaking legacy.
133977	134039	**
133978		-** See Also: generateColumnNames()
	134040	+** See Also: sqlite3GenerateColumnNames()
133979	134041	*/
133980	134042	SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
133981	134043	Parse pParse, / Parsing context */
133982	134044	ExprList pEList, / Expr list from which to derive column names */
133983	134045	i16 pnCol, / Write the number of columns here */
		@@ -134676,10 +134738,11 @@
134676	134738	int nLimit = 0; /* Initialize to suppress harmless compiler warning */
134677	134739	assert( !pPrior->pLimit );
134678	134740	pPrior->iLimit = p->iLimit;
134679	134741	pPrior->iOffset = p->iOffset;
134680	134742	pPrior->pLimit = p->pLimit;
	134743	+ SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL left...\n"));
134681	134744	rc = sqlite3Select(pParse, pPrior, &dest);
134682	134745	pPrior->pLimit = 0;
134683	134746	if( rc ){
134684	134747	goto multi_select_end;
134685	134748	}
		@@ -134693,10 +134756,11 @@
134693	134756	sqlite3VdbeAddOp3(v, OP_OffsetLimit,
134694	134757	p->iLimit, p->iOffset+1, p->iOffset);
134695	134758	}
134696	134759	}
134697	134760	ExplainQueryPlan((pParse, 1, "UNION ALL"));
	134761	+ SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL right...\n"));
134698	134762	rc = sqlite3Select(pParse, p, &dest);
134699	134763	testcase( rc!=SQLITE_OK );
134700	134764	pDelete = p->pPrior;
134701	134765	p->pPrior = pPrior;
134702	134766	p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
		@@ -134745,10 +134809,11 @@
134745	134809
134746	134810	/* Code the SELECT statements to our left
134747	134811	*/
134748	134812	assert( !pPrior->pOrderBy );
134749	134813	sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
	134814	+ SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION left...\n"));
134750	134815	rc = sqlite3Select(pParse, pPrior, &uniondest);
134751	134816	if( rc ){
134752	134817	goto multi_select_end;
134753	134818	}
134754	134819
		@@ -134764,10 +134829,11 @@
134764	134829	pLimit = p->pLimit;
134765	134830	p->pLimit = 0;
134766	134831	uniondest.eDest = op;
134767	134832	ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
134768	134833	sqlite3SelectOpName(p->op)));
	134834	+ SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION right...\n"));
134769	134835	rc = sqlite3Select(pParse, p, &uniondest);
134770	134836	testcase( rc!=SQLITE_OK );
134771	134837	assert( p->pOrderBy==0 );
134772	134838	pDelete = p->pPrior;
134773	134839	p->pPrior = pPrior;
		@@ -134824,10 +134890,11 @@
134824	134890	assert( p->pEList );
134825	134891
134826	134892	/* Code the SELECTs to our left into temporary table "tab1".
134827	134893	*/
134828	134894	sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
	134895	+ SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT left...\n"));
134829	134896	rc = sqlite3Select(pParse, pPrior, &intersectdest);
134830	134897	if( rc ){
134831	134898	goto multi_select_end;
134832	134899	}
134833	134900
		@@ -134840,10 +134907,11 @@
134840	134907	pLimit = p->pLimit;
134841	134908	p->pLimit = 0;
134842	134909	intersectdest.iSDParm = tab2;
134843	134910	ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
134844	134911	sqlite3SelectOpName(p->op)));
	134912	+ SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT right...\n"));
134845	134913	rc = sqlite3Select(pParse, p, &intersectdest);
134846	134914	testcase( rc!=SQLITE_OK );
134847	134915	pDelete = p->pPrior;
134848	134916	p->pPrior = pPrior;
134849	134917	if( p->nSelectRow>pPrior->nSelectRow ){
		@@ -136339,10 +136407,11 @@
136339	136407	typedef struct WhereConst WhereConst;
136340	136408	struct WhereConst {
136341	136409	Parse pParse; / Parsing context */
136342	136410	int nConst; /* Number for COLUMN=CONSTANT terms */
136343	136411	int nChng; /* Number of times a constant is propagated */
	136412	+ int bHasAffBlob; /* At least one column in apExpr[] as affinity BLOB */
136344	136413	Expr *apExpr; / [i2] is COLUMN and [i2+1] is VALUE */
136345	136414	};
136346	136415
136347	136416	/*
136348	136417	** Add a new entry to the pConst object. Except, do not add duplicate
		@@ -136376,10 +136445,13 @@
136376	136445	if( pE2->iTable==pColumn->iTable
136377	136446	&& pE2->iColumn==pColumn->iColumn
136378	136447	){
136379	136448	return; /* Already present. Return without doing anything. */
136380	136449	}
	136450	+ }
	136451	+ if( sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){
	136452	+ pConst->bHasAffBlob = 1;
136381	136453	}
136382	136454
136383	136455	pConst->nConst++;
136384	136456	pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
136385	136457	pConst->nConst2sizeof(Expr*));
		@@ -136418,30 +136490,38 @@
136418	136490	constInsert(pConst,pLeft,pRight,pExpr);
136419	136491	}
136420	136492	}
136421	136493
136422	136494	/*
136423		-** This is a Walker expression callback. pExpr is a candidate expression
136424		-** to be replaced by a value. If pExpr is equivalent to one of the
136425		-** columns named in pWalker->u.pConst, then overwrite it with its
136426		-** corresponding value.
	136495	+** This is a helper function for Walker callback propagateConstantExprRewrite().
	136496	+**
	136497	+** Argument pExpr is a candidate expression to be replaced by a value. If
	136498	+** pExpr is equivalent to one of the columns named in pWalker->u.pConst,
	136499	+** then overwrite it with the corresponding value. Except, do not do so
	136500	+** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr
	136501	+** is SQLITE_AFF_BLOB.
136427	136502	*/
136428		-static int propagateConstantExprRewrite(Walker pWalker, Expr pExpr){
	136503	+static int propagateConstantExprRewriteOne(
	136504	+ WhereConst *pConst,
	136505	+ Expr *pExpr,
	136506	+ int bIgnoreAffBlob
	136507	+){
136429	136508	int i;
136430		- WhereConst *pConst;
136431	136509	if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
136432	136510	if( ExprHasProperty(pExpr, EP_FixedCol\|EP_FromJoin) ){
136433	136511	testcase( ExprHasProperty(pExpr, EP_FixedCol) );
136434	136512	testcase( ExprHasProperty(pExpr, EP_FromJoin) );
136435	136513	return WRC_Continue;
136436	136514	}
136437		- pConst = pWalker->u.pConst;
136438	136515	for(i=0; i<pConst->nConst; i++){
136439	136516	Expr pColumn = pConst->apExpr[i2];
136440	136517	if( pColumn==pExpr ) continue;
136441	136518	if( pColumn->iTable!=pExpr->iTable ) continue;
136442	136519	if( pColumn->iColumn!=pExpr->iColumn ) continue;
	136520	+ if( bIgnoreAffBlob && sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){
	136521	+ break;
	136522	+ }
136443	136523	/* A match is found. Add the EP_FixedCol property */
136444	136524	pConst->nChng++;
136445	136525	ExprClearProperty(pExpr, EP_Leaf);
136446	136526	ExprSetProperty(pExpr, EP_FixedCol);
136447	136527	assert( pExpr->pLeft==0 );
		@@ -136448,10 +136528,45 @@
136448	136528	pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
136449	136529	break;
136450	136530	}
136451	136531	return WRC_Prune;
136452	136532	}
	136533	+
	136534	+/*
	136535	+** This is a Walker expression callback. pExpr is a node from the WHERE
	136536	+** clause of a SELECT statement. This function examines pExpr to see if
	136537	+** any substitutions based on the contents of pWalker->u.pConst should
	136538	+** be made to pExpr or its immediate children.
	136539	+**
	136540	+** A substitution is made if:
	136541	+**
	136542	+** + pExpr is a column with an affinity other than BLOB that matches
	136543	+** one of the columns in pWalker->u.pConst, or
	136544	+**
	136545	+** + pExpr is a binary comparison operator (=, <=, >=, <, >) that
	136546	+** uses an affinity other than TEXT and one of its immediate
	136547	+** children is a column that matches one of the columns in
	136548	+** pWalker->u.pConst.
	136549	+*/
	136550	+static int propagateConstantExprRewrite(Walker pWalker, Expr pExpr){
	136551	+ WhereConst *pConst = pWalker->u.pConst;
	136552	+ assert( TK_GT==TK_EQ+1 );
	136553	+ assert( TK_LE==TK_EQ+2 );
	136554	+ assert( TK_LT==TK_EQ+3 );
	136555	+ assert( TK_GE==TK_EQ+4 );
	136556	+ if( pConst->bHasAffBlob ){
	136557	+ if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE)
	136558	+ \|\| pExpr->op==TK_IS
	136559	+ ){
	136560	+ propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0);
	136561	+ if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){
	136562	+ propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0);
	136563	+ }
	136564	+ }
	136565	+ }
	136566	+ return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob);
	136567	+}
136453	136568
136454	136569	/*
136455	136570	** The WHERE-clause constant propagation optimization.
136456	136571	**
136457	136572	** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
		@@ -136484,10 +136599,25 @@
136484	136599	** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol
136485	136600	** and the "123" value is hung off of the pLeft pointer. Code generator
136486	136601	** routines know to generate the constant "123" instead of looking up the
136487	136602	** column value. Also, to avoid collation problems, this optimization is
136488	136603	** only attempted if the "a=123" term uses the default BINARY collation.
	136604	+**
	136605	+** 2021-05-25 forum post 6a06202608: Another troublesome case is...
	136606	+**
	136607	+** CREATE TABLE t1(x);
	136608	+** INSERT INTO t1 VALUES(10.0);
	136609	+** SELECT 1 FROM t1 WHERE x=10 AND x LIKE 10;
	136610	+**
	136611	+** The query should return no rows, because the t1.x value is '10.0' not '10'
	136612	+** and '10.0' is not LIKE '10'. But if we are not careful, the first WHERE
	136613	+** term "x=10" will cause the second WHERE term to become "10 LIKE 10",
	136614	+** resulting in a false positive. To avoid this, constant propagation for
	136615	+** columns with BLOB affinity is only allowed if the constant is used with
	136616	+** operators ==, <=, <, >=, >, or IS in a way that will cause the correct
	136617	+** type conversions to occur. See logic associated with the bHasAffBlob flag
	136618	+** for details.
136489	136619	*/
136490	136620	static int propagateConstants(
136491	136621	Parse pParse, / The parsing context */
136492	136622	Select p / The query in which to propagate constants */
136493	136623	){
		@@ -136497,10 +136627,11 @@
136497	136627	x.pParse = pParse;
136498	136628	do{
136499	136629	x.nConst = 0;
136500	136630	x.nChng = 0;
136501	136631	x.apExpr = 0;
	136632	+ x.bHasAffBlob = 0;
136502	136633	findConstInWhere(&x, p->pWhere);
136503	136634	if( x.nConst ){
136504	136635	memset(&w, 0, sizeof(w));
136505	136636	w.pParse = pParse;
136506	136637	w.xExprCallback = propagateConstantExprRewrite;
		@@ -136933,29 +137064,32 @@
136933	137064	if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
136934	137065	*ppContext = p;
136935	137066	return &p->a[i];
136936	137067	}
136937	137068	}
	137069	+ if( p->bView ) break;
136938	137070	}
136939	137071	return 0;
136940	137072	}
136941	137073
136942	137074	/* The code generator maintains a stack of active WITH clauses
136943	137075	** with the inner-most WITH clause being at the top of the stack.
136944	137076	**
136945	137077	** This routine pushes the WITH clause passed as the second argument
136946	137078	** onto the top of the stack. If argument bFree is true, then this
136947		-** WITH clause will never be popped from the stack. In this case it
136948		-** should be freed along with the Parse object. In other cases, when
	137079	+** WITH clause will never be popped from the stack but should instead
	137080	+** be freed along with the Parse object. In other cases, when
136949	137081	** bFree==0, the With object will be freed along with the SELECT
136950	137082	** statement with which it is associated.
136951	137083	*/
136952	137084	SQLITE_PRIVATE void sqlite3WithPush(Parse pParse, With pWith, u8 bFree){
136953	137085	if( pWith ){
136954		- assert( pParse->pWith!=pWith );
136955		- pWith->pOuter = pParse->pWith;
136956		- pParse->pWith = pWith;
	137086	+ if( pParse->nErr==0 ){
	137087	+ assert( pParse->pWith!=pWith );
	137088	+ pWith->pOuter = pParse->pWith;
	137089	+ pParse->pWith = pWith;
	137090	+ }
136957	137091	if( bFree ){
136958	137092	sqlite3ParserAddCleanup(pParse,
136959	137093	(void()(sqlite3,void*))sqlite3WithDelete,
136960	137094	pWith);
136961	137095	testcase( pParse->earlyCleanup );
		@@ -136987,15 +137121,28 @@
136987	137121
136988	137122	assert( pFrom->pTab==0 );
136989	137123	if( pParse->pWith==0 ){
136990	137124	/* There are no WITH clauses in the stack. No match is possible */
136991	137125	return 0;
	137126	+ }
	137127	+ if( pParse->nErr ){
	137128	+ /* Prior errors might have left pParse->pWith in a goofy state, so
	137129	+ ** go no further. */
	137130	+ return 0;
136992	137131	}
136993	137132	if( pFrom->zDatabase!=0 ){
136994	137133	/* The FROM term contains a schema qualifier (ex: main.t1) and so
136995	137134	** it cannot possibly be a CTE reference. */
136996	137135	return 0;
	137136	+ }
	137137	+ if( pFrom->fg.notCte ){
	137138	+ /* The FROM term is specifically excluded from matching a CTE.
	137139	+ ** (1) It is part of a trigger that used to have zDatabase but had
	137140	+ ** zDatabase removed by sqlite3FixTriggerStep().
	137141	+ ** (2) This is the first term in the FROM clause of an UPDATE.
	137142	+ */
	137143	+ return 0;
136997	137144	}
136998	137145	pCte = searchWith(pParse->pWith, pFrom, &pWith);
136999	137146	if( pCte ){
137000	137147	sqlite3 *db = pParse->db;
137001	137148	Table *pTab;
		@@ -137237,10 +137384,19 @@
137237	137384	/* Renumber selId because it has been copied from a view */
137238	137385	p->selId = ++pParse->nSelect;
137239	137386	}
137240	137387	pTabList = p->pSrc;
137241	137388	pEList = p->pEList;
	137389	+ if( pParse->pWith && (p->selFlags & SF_View) ){
	137390	+ if( p->pWith==0 ){
	137391	+ p->pWith = (With*)sqlite3DbMallocZero(db, sizeof(With));
	137392	+ if( p->pWith==0 ){
	137393	+ return WRC_Abort;
	137394	+ }
	137395	+ }
	137396	+ p->pWith->bView = 1;
	137397	+ }
137242	137398	sqlite3WithPush(pParse, p->pWith, 0);
137243	137399
137244	137400	/* Make sure cursor numbers have been assigned to all entries in
137245	137401	** the FROM clause of the SELECT statement.
137246	137402	*/
		@@ -138124,11 +138280,11 @@
138124	138280	}
138125	138281	}
138126	138282	}
138127	138283
138128	138284	if( pDest->eDest==SRT_Output ){
138129		- generateColumnNames(pParse, p);
	138285	+ sqlite3GenerateColumnNames(pParse, p);
138130	138286	}
138131	138287
138132	138288	#ifndef SQLITE_OMIT_WINDOWFUNC
138133	138289	if( sqlite3WindowRewrite(pParse, p) ){
138134	138290	assert( db->mallocFailed \|\| pParse->nErr>0 );
		@@ -138318,23 +138474,12 @@
138318	138474	/* Generate code for all sub-queries in the FROM clause
138319	138475	*/
138320	138476	pSub = pItem->pSelect;
138321	138477	if( pSub==0 ) continue;
138322	138478
138323		- /* The code for a subquery should only be generated once, though it is
138324		- ** technically harmless for it to be generated multiple times. The
138325		- ** following assert() will detect if something changes to cause
138326		- ** the same subquery to be coded multiple times, as a signal to the
138327		- ** developers to try to optimize the situation.
138328		- **
138329		- ** Update 2019-07-24:
138330		- ** See ticket https://sqlite.org/src/tktview/c52b09c7f38903b1311cec40.
138331		- ** The dbsqlfuzz fuzzer found a case where the same subquery gets
138332		- ** coded twice. So this assert() now becomes a testcase(). It should
138333		- ** be very rare, though.
138334		- */
138335		- testcase( pItem->addrFillSub!=0 );
	138479	+ /* The code for a subquery should only be generated once. */
	138480	+ assert( pItem->addrFillSub==0 );
138336	138481
138337	138482	/* Increment Parse.nHeight by the height of the largest expression
138338	138483	** tree referred to by this, the parent select. The child select
138339	138484	** may contain expression trees of at most
138340	138485	** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
		@@ -138417,18 +138562,17 @@
138417	138562	sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub);
138418	138563	}
138419	138564	sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
138420	138565	pSub->nSelectRow = pPrior->pSelect->nSelectRow;
138421	138566	}else{
138422		- /* Materalize the view. If the view is not correlated, generate a
	138567	+ /* Materialize the view. If the view is not correlated, generate a
138423	138568	** subroutine to do the materialization so that subsequent uses of
138424	138569	** the same view can reuse the materialization. */
138425	138570	int topAddr;
138426	138571	int onceAddr = 0;
138427	138572	int retAddr;
138428	138573
138429		- testcase( pItem->addrFillSub==0 ); /* Ticket c52b09c7f38903b1311 */
138430	138574	pItem->regReturn = ++pParse->nMem;
138431	138575	topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
138432	138576	pItem->addrFillSub = topAddr+1;
138433	138577	if( pItem->fg.isCorrelated==0 ){
138434	138578	/* If the subquery is not correlated and if we are not inside of
		@@ -140327,19 +140471,10 @@
140327	140471	pItem->zEName = sqlite3DbStrDup(db, pList->a[i].zEName);
140328	140472	pItem->eEName = pList->a[i].eEName;
140329	140473	}
140330	140474	}
140331	140475	}
140332		- if( !db->mallocFailed ){
140333		- Vdbe *v = pParse->pVdbe;
140334		- assert( v!=0 );
140335		- sqlite3VdbeSetNumCols(v, pNew->nExpr);
140336		- for(i=0; i<pNew->nExpr; i++){
140337		- sqlite3VdbeSetColName(v, i, COLNAME_NAME, pNew->a[i].zEName,
140338		- SQLITE_TRANSIENT);
140339		- }
140340		- }
140341	140476	return pNew;
140342	140477	}
140343	140478
140344	140479	/*
140345	140480	** Generate code for the RETURNING trigger. Unlike other triggers
		@@ -140351,17 +140486,31 @@
140351	140486	Trigger pTrigger, / The trigger step that defines the RETURNING */
140352	140487	Table pTab, / The table to code triggers from */
140353	140488	int regIn /* The first in an array of registers */
140354	140489	){
140355	140490	Vdbe *v = pParse->pVdbe;
	140491	+ sqlite3 *db = pParse->db;
140356	140492	ExprList *pNew;
140357	140493	Returning *pReturning;
	140494	+ Select sSelect;
	140495	+ SrcList sFrom;
140358	140496
140359	140497	assert( v!=0 );
140360	140498	assert( pParse->bReturning );
140361	140499	pReturning = pParse->u1.pReturning;
140362	140500	assert( pTrigger == &(pReturning->retTrig) );
	140501	+ memset(&sSelect, 0, sizeof(sSelect));
	140502	+ memset(&sFrom, 0, sizeof(sFrom));
	140503	+ sSelect.pEList = sqlite3ExprListDup(db, pReturning->pReturnEL, 0);
	140504	+ sSelect.pSrc = &sFrom;
	140505	+ sFrom.nSrc = 1;
	140506	+ sFrom.a[0].pTab = pTab;
	140507	+ sqlite3SelectPrep(pParse, &sSelect, 0);
	140508	+ if( db->mallocFailed==0 && pParse->nErr==0 ){
	140509	+ sqlite3GenerateColumnNames(pParse, &sSelect);
	140510	+ }
	140511	+ sqlite3ExprListDelete(db, sSelect.pEList);
140363	140512	pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
140364	140513	if( pNew ){
140365	140514	NameContext sNC;
140366	140515	memset(&sNC, 0, sizeof(sNC));
140367	140516	if( pReturning->nRetCol==0 ){
		@@ -140378,17 +140527,18 @@
140378	140527	int nCol = pNew->nExpr;
140379	140528	int reg = pParse->nMem+1;
140380	140529	pParse->nMem += nCol+2;
140381	140530	pReturning->iRetReg = reg;
140382	140531	for(i=0; i<nCol; i++){
140383		- sqlite3ExprCodeFactorable(pParse, pNew->a[i].pExpr, reg+i);
	140532	+ Expr *pCol = pNew->a[i].pExpr;
	140533	+ sqlite3ExprCodeFactorable(pParse, pCol, reg+i);
140384	140534	}
140385	140535	sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, i, reg+i);
140386	140536	sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1);
140387	140537	sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1);
140388	140538	}
140389		- sqlite3ExprListDelete(pParse->db, pNew);
	140539	+ sqlite3ExprListDelete(db, pNew);
140390	140540	pParse->eTriggerOp = 0;
140391	140541	pParse->pTriggerTab = 0;
140392	140542	}
140393	140543	}
140394	140544
		@@ -141067,10 +141217,11 @@
141067	141217	pSrc = sqlite3SrcListDup(db, pTabList, 0);
141068	141218	pWhere2 = sqlite3ExprDup(db, pWhere, 0);
141069	141219
141070	141220	assert( pTabList->nSrc>1 );
141071	141221	if( pSrc ){
	141222	+ pSrc->a[0].fg.notCte = 1;
141072	141223	pSrc->a[0].iCursor = -1;
141073	141224	pSrc->a[0].pTab->nTabRef--;
141074	141225	pSrc->a[0].pTab = 0;
141075	141226	}
141076	141227	if( pPk ){
		@@ -145593,11 +145744,11 @@
145593	145744	if( r1!=regBase+j ){
145594	145745	if( nReg==1 ){
145595	145746	sqlite3ReleaseTempReg(pParse, regBase);
145596	145747	regBase = r1;
145597	145748	}else{
145598		- sqlite3VdbeAddOp2(v, OP_SCopy, r1, regBase+j);
	145749	+ sqlite3VdbeAddOp2(v, OP_Copy, r1, regBase+j);
145599	145750	}
145600	145751	}
145601	145752	if( pTerm->eOperator & WO_IN ){
145602	145753	if( pTerm->pExpr->flags & EP_xIsSelect ){
145603	145754	/* No affinity ever needs to be (or should be) applied to a value
		@@ -145610,11 +145761,11 @@
145610	145761	Expr *pRight = pTerm->pExpr->pRight;
145611	145762	if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){
145612	145763	sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
145613	145764	VdbeCoverage(v);
145614	145765	}
145615		- if( pParse->db->mallocFailed==0 ){
	145766	+ if( pParse->db->mallocFailed==0 && pParse->nErr==0 ){
145616	145767	if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){
145617	145768	zAff[j] = SQLITE_AFF_BLOB;
145618	145769	}
145619	145770	if( sqlite3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){
145620	145771	zAff[j] = SQLITE_AFF_BLOB;
		@@ -145959,11 +146110,11 @@
145959	146110	for(i=0; i<nReg; i++){
145960	146111	sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
145961	146112	}
145962	146113	}
145963	146114	}else{
145964		- assert( nReg==1 );
	146115	+ assert( nReg==1 \|\| pParse->nErr );
145965	146116	sqlite3ExprCode(pParse, p, iReg);
145966	146117	}
145967	146118	}
145968	146119
145969	146120	/* An instance of the IdxExprTrans object carries information about a
		@@ -147007,11 +147158,11 @@
147007	147158	}
147008	147159	if( pAndExpr ){
147009	147160	/* The extra 0x10000 bit on the opcode is masked off and does not
147010	147161	** become part of the new Expr.op. However, it does make the
147011	147162	** op==TK_AND comparison inside of sqlite3PExpr() false, and this
147012		- ** prevents sqlite3PExpr() from implementing AND short-circuit
	147163	+ ** prevents sqlite3PExpr() from applying the AND short-circuit
147013	147164	** optimization, which we do not want here. */
147014	147165	pAndExpr = sqlite3PExpr(pParse, TK_AND\|0x10000, 0, pAndExpr);
147015	147166	}
147016	147167	}
147017	147168
		@@ -147023,14 +147174,20 @@
147023	147174	for(ii=0; ii<pOrWc->nTerm; ii++){
147024	147175	WhereTerm *pOrTerm = &pOrWc->a[ii];
147025	147176	if( pOrTerm->leftCursor==iCur \|\| (pOrTerm->eOperator & WO_AND)!=0 ){
147026	147177	WhereInfo pSubWInfo; / Info for single OR-term scan */
147027	147178	Expr pOrExpr = pOrTerm->pExpr; / Current OR clause term */
	147179	+ Expr pDelete; / Local copy of OR clause term */
147028	147180	int jmp1 = 0; /* Address of jump operation */
147029	147181	testcase( (pTabItem[0].fg.jointype & JT_LEFT)!=0
147030	147182	&& !ExprHasProperty(pOrExpr, EP_FromJoin)
147031	147183	); /* See TH3 vtab25.400 and ticket 614b25314c766238 */
	147184	+ pDelete = pOrExpr = sqlite3ExprDup(db, pOrExpr, 0);
	147185	+ if( db->mallocFailed ){
	147186	+ sqlite3ExprDelete(db, pDelete);
	147187	+ continue;
	147188	+ }
147032	147189	if( pAndExpr ){
147033	147190	pAndExpr->pLeft = pOrExpr;
147034	147191	pOrExpr = pAndExpr;
147035	147192	}
147036	147193	/* Loop through table entries that match term pOrTerm. */
		@@ -147141,10 +147298,11 @@
147141	147298
147142	147299	/* Finish the loop through table entries that match term pOrTerm. */
147143	147300	sqlite3WhereEnd(pSubWInfo);
147144	147301	ExplainQueryPlanPop(pParse);
147145	147302	}
	147303	+ sqlite3ExprDelete(db, pDelete);
147146	147304	}
147147	147305	}
147148	147306	ExplainQueryPlanPop(pParse);
147149	147307	pLevel->u.pCovidx = pCov;
147150	147308	if( pCov ) pLevel->iIdxCur = iCovCur;
		@@ -151888,10 +152046,11 @@
151888	152046	Expr *pExpr;
151889	152047	pExpr = pTerm->pExpr;
151890	152048	if( (!ExprHasProperty(pExpr, EP_FromJoin) \|\| pExpr->iRightJoinTable==iTab)
151891	152049	&& (isLeft==0 \|\| ExprHasProperty(pExpr, EP_FromJoin))
151892	152050	&& sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
	152051	+ && (pTerm->wtFlags & TERM_VNULL)==0
151893	152052	){
151894	152053	return 1;
151895	152054	}
151896	152055	}
151897	152056	return 0;
		@@ -155605,11 +155764,11 @@
155605	155764	** are invoked in the correct order as described under "SELECT REWRITING"
155606	155765	** at the top of this file.
155607	155766	*/
155608	155767	SQLITE_PRIVATE int sqlite3WindowRewrite(Parse pParse, Select p){
155609	155768	int rc = SQLITE_OK;
155610		- if( p->pWin && p->pPrior==0 && (p->selFlags & SF_WinRewrite)==0 ){
	155769	+ if( p->pWin && p->pPrior==0 && ALWAYS((p->selFlags & SF_WinRewrite)==0) ){
155611	155770	Vdbe *v = sqlite3GetVdbe(pParse);
155612	155771	sqlite3 *db = pParse->db;
155613	155772	Select pSub = 0; / The subquery */
155614	155773	SrcList *pSrc = p->pSrc;
155615	155774	Expr *pWhere = p->pWhere;
		@@ -155631,10 +155790,11 @@
155631	155790	}
155632	155791	sqlite3AggInfoPersistWalkerInit(&w, pParse);
155633	155792	sqlite3WalkSelect(&w, p);
155634	155793	if( (p->selFlags & SF_Aggregate)==0 ){
155635	155794	w.xExprCallback = disallowAggregatesInOrderByCb;
	155795	+ w.xSelectCallback = 0;
155636	155796	sqlite3WalkExprList(&w, p->pOrderBy);
155637	155797	}
155638	155798
155639	155799	p->pSrc = 0;
155640	155800	p->pWhere = 0;
		@@ -158141,12 +158301,13 @@
158141	158301	#define TK_VECTOR 176
158142	158302	#define TK_SELECT_COLUMN 177
158143	158303	#define TK_IF_NULL_ROW 178
158144	158304	#define TK_ASTERISK 179
158145	158305	#define TK_SPAN 180
158146		-#define TK_SPACE 181
158147		-#define TK_ILLEGAL 182
	158306	+#define TK_ERROR 181
	158307	+#define TK_SPACE 182
	158308	+#define TK_ILLEGAL 183
158148	158309	#endif
158149	158310	/************** End token definitions *************************************/
158150	158311
158151	158312	/* The next sections is a series of control #defines.
158152	158313	** various aspects of the generated parser.
		@@ -158202,33 +158363,33 @@
158202	158363	#ifndef INTERFACE
158203	158364	# define INTERFACE 1
158204	158365	#endif
158205	158366	/*********** Begin control #defines ***************************************/
158206	158367	#define YYCODETYPE unsigned short int
158207		-#define YYNOCODE 316
	158368	+#define YYNOCODE 317
158208	158369	#define YYACTIONTYPE unsigned short int
158209	158370	#define YYWILDCARD 101
158210	158371	#define sqlite3ParserTOKENTYPE Token
158211	158372	typedef union {
158212	158373	int yyinit;
158213	158374	sqlite3ParserTOKENTYPE yy0;
158214		- Window* yy19;
158215		- struct TrigEvent yy50;
158216		- int yy60;
158217		- struct FrameBound yy113;
158218		- Upsert* yy178;
158219		- With* yy195;
158220		- IdList* yy288;
158221		- SrcList* yy291;
158222		- Select* yy307;
158223		- ExprList* yy338;
158224		- TriggerStep* yy483;
158225		- const char* yy528;
158226		- u8 yy570;
158227		- Expr* yy602;
158228		- Cte* yy607;
158229		- struct {int value; int mask;} yy615;
	158375	+ Window* yy49;
	158376	+ ExprList* yy70;
	158377	+ Select* yy81;
	158378	+ With* yy103;
	158379	+ struct FrameBound yy117;
	158380	+ struct {int value; int mask;} yy139;
	158381	+ SrcList* yy153;
	158382	+ TriggerStep* yy157;
	158383	+ Upsert* yy190;
	158384	+ struct TrigEvent yy262;
	158385	+ Cte* yy329;
	158386	+ int yy376;
	158387	+ Expr* yy404;
	158388	+ IdList* yy436;
	158389	+ const char* yy504;
	158390	+ u8 yy552;
158230	158391	} YYMINORTYPE;
158231	158392	#ifndef YYSTACKDEPTH
158232	158393	#define YYSTACKDEPTH 100
158233	158394	#endif
158234	158395	#define sqlite3ParserARG_SDECL
		@@ -158243,11 +158404,11 @@
158243	158404	#define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
158244	158405	#define YYFALLBACK 1
158245	158406	#define YYNSTATE 570
158246	158407	#define YYNRULE 398
158247	158408	#define YYNRULE_WITH_ACTION 337
158248		-#define YYNTOKEN 183
	158409	+#define YYNTOKEN 184
158249	158410	#define YY_MAX_SHIFT 569
158250	158411	#define YY_MIN_SHIFTREDUCE 825
158251	158412	#define YY_MAX_SHIFTREDUCE 1222
158252	158413	#define YY_ERROR_ACTION 1223
158253	158414	#define YY_ACCEPT_ACTION 1224
		@@ -158318,545 +158479,546 @@
158318	158479	** yy_reduce_ofst[] For each state, the offset into yy_action for
158319	158480	** shifting non-terminals after a reduce.
158320	158481	** yy_default[] Default action for each state.
158321	158482	**
158322	158483	********* Begin parsing tables ********************************************/
158323		-#define YY_ACTTAB_COUNT (2020)
	158484	+#define YY_ACTTAB_COUNT (2023)
158324	158485	static const YYACTIONTYPE yy_action[] = {
158325		- /* 0 */ 563, 1295, 563, 1274, 168, 361, 115, 112, 218, 373,
	158486	+ /* 0 */ 563, 1295, 563, 1274, 168, 1257, 115, 112, 218, 373,
158326	158487	/* 10 */ 563, 1295, 374, 563, 488, 563, 115, 112, 218, 406,
158327	158488	/* 20 */ 1300, 1300, 41, 41, 41, 41, 514, 1504, 520, 1298,
158328		- /* 30 */ 1298, 959, 41, 41, 1257, 71, 71, 51, 51, 960,
	158489	+ /* 30 */ 1298, 959, 41, 41, 1260, 71, 71, 51, 51, 960,
158329	158490	/* 40 */ 557, 557, 557, 122, 123, 113, 1200, 1200, 1035, 1038,
158330	158491	/* 50 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 414, 406,
158331	158492	/* 60 */ 273, 273, 273, 273, 115, 112, 218, 115, 112, 218,
158332		- /* 70 */ 197, 268, 545, 560, 515, 560, 1260, 563, 385, 248,
	158493	+ /* 70 */ 197, 268, 545, 560, 515, 560, 211, 563, 385, 248,
158333	158494	/* 80 */ 215, 521, 399, 122, 123, 113, 1200, 1200, 1035, 1038,
158334	158495	/* 90 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 540, 13,
158335	158496	/* 100 */ 13, 1259, 119, 119, 119, 119, 118, 118, 117, 117,
158336		- /* 110 */ 117, 116, 441, 1176, 419, 1531, 446, 137, 512, 1539,
158337		- /* 120 */ 1545, 372, 1547, 6, 371, 1176, 1148, 1584, 1148, 406,
158338		- /* 130 */ 1545, 534, 115, 112, 218, 1267, 99, 441, 121, 121,
	158497	+ /* 110 */ 117, 116, 441, 1176, 419, 197, 446, 320, 512, 1539,
	158498	+ /* 120 */ 1545, 372, 1547, 6, 371, 1176, 1148, 394, 1148, 406,
	158499	+ /* 130 */ 1545, 534, 115, 112, 218, 1415, 99, 30, 121, 121,
158339	158500	/* 140 */ 121, 121, 119, 119, 119, 119, 118, 118, 117, 117,
158340	158501	/* 150 */ 117, 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038,
158341		- /* 160 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 197, 1176,
158342		- /* 170 */ 1177, 1178, 241, 304, 554, 501, 498, 497, 473, 124,
158343		- /* 180 */ 394, 1176, 1177, 1178, 1176, 496, 119, 119, 119, 119,
158344		- /* 190 */ 118, 118, 117, 117, 117, 116, 441, 139, 540, 406,
	158502	+ /* 160 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 31, 1176,
	158503	+ /* 170 */ 1177, 1178, 241, 357, 1558, 501, 498, 497, 317, 124,
	158504	+ /* 180 */ 319, 1176, 1177, 1178, 1176, 496, 119, 119, 119, 119,
	158505	+ /* 190 */ 118, 118, 117, 117, 117, 116, 441, 139, 96, 406,
158345	158506	/* 200 */ 121, 121, 121, 121, 114, 117, 117, 117, 116, 441,
158346	158507	/* 210 */ 541, 1532, 119, 119, 119, 119, 118, 118, 117, 117,
158347	158508	/* 220 */ 117, 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038,
158348		- /* 230 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 406, 320,
158349		- /* 240 */ 1176, 1177, 1178, 81, 342, 1590, 396, 80, 119, 119,
158350		- /* 250 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 1176,
158351		- /* 260 */ 211, 450, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158352		- /* 270 */ 1028, 120, 120, 121, 121, 121, 121, 251, 450, 449,
158353		- /* 280 */ 273, 273, 119, 119, 119, 119, 118, 118, 117, 117,
158354		- /* 290 */ 117, 116, 441, 560, 1224, 1, 1, 569, 2, 1228,
158355		- /* 300 */ 317, 1176, 319, 1561, 305, 337, 140, 340, 406, 430,
158356		- /* 310 */ 469, 1533, 1197, 1308, 348, 1176, 1177, 1178, 168, 462,
	158509	+ /* 230 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 406, 441,
	158510	+ /* 240 */ 1176, 1177, 1178, 81, 439, 439, 439, 80, 119, 119,
	158511	+ /* 250 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 488,
	158512	+ /* 260 */ 1176, 318, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
	158513	+ /* 270 */ 1028, 120, 120, 121, 121, 121, 121, 493, 1025, 1025,
	158514	+ /* 280 */ 1036, 1039, 119, 119, 119, 119, 118, 118, 117, 117,
	158515	+ /* 290 */ 117, 116, 441, 1584, 995, 1224, 1, 1, 569, 2,
	158516	+ /* 300 */ 1228, 1267, 137, 1503, 245, 305, 473, 140, 406, 860,
	158517	+ /* 310 */ 561, 1176, 914, 914, 1308, 359, 1176, 1177, 1178, 462,
158357	158518	/* 320 */ 330, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158358	158519	/* 330 */ 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158359		- /* 340 */ 1028, 120, 120, 121, 121, 121, 121, 273, 273, 563,
158360		- /* 350 */ 83, 450, 416, 1564, 569, 2, 1228, 1176, 1177, 1178,
158361		- /* 360 */ 560, 305, 471, 140, 944, 995, 860, 563, 467, 1197,
158362		- /* 370 */ 1308, 13, 13, 137, 229, 118, 118, 117, 117, 117,
158363		- /* 380 */ 116, 441, 96, 318, 946, 504, 424, 361, 562, 71,
158364		- /* 390 */ 71, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158365		- /* 400 */ 116, 441, 427, 205, 273, 273, 445, 1015, 259, 276,
158366		- /* 410 */ 356, 507, 351, 506, 246, 406, 959, 560, 328, 344,
158367		- /* 420 */ 347, 315, 860, 1006, 960, 126, 545, 1005, 313, 304,
158368		- /* 430 */ 554, 229, 538, 1539, 148, 544, 281, 6, 203, 122,
	158520	+ /* 340 */ 1028, 120, 120, 121, 121, 121, 121, 328, 273, 273,
	158521	+ /* 350 */ 1015, 83, 1029, 425, 1564, 569, 2, 1228, 304, 554,
	158522	+ /* 360 */ 925, 560, 305, 944, 140, 860, 1006, 1176, 1177, 1178,
	158523	+ /* 370 */ 1005, 1308, 411, 213, 511, 229, 119, 119, 119, 119,
	158524	+ /* 380 */ 118, 118, 117, 117, 117, 116, 441, 519, 347, 116,
	158525	+ /* 390 */ 441, 119, 119, 119, 119, 118, 118, 117, 117, 117,
	158526	+ /* 400 */ 116, 441, 1005, 1005, 1007, 273, 273, 445, 563, 16,
	158527	+ /* 410 */ 16, 1590, 563, 1540, 563, 406, 1176, 6, 560, 344,
	158528	+ /* 420 */ 182, 118, 118, 117, 117, 117, 116, 441, 416, 142,
	158529	+ /* 430 */ 71, 71, 229, 563, 71, 71, 55, 55, 203, 122,
158369	158530	/* 440 */ 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120,
158370		- /* 450 */ 121, 121, 121, 121, 563, 217, 563, 12, 406, 1005,
158371		- /* 460 */ 1005, 1007, 502, 445, 119, 119, 119, 119, 118, 118,
158372		- /* 470 */ 117, 117, 117, 116, 441, 452, 71, 71, 70, 70,
158373		- /* 480 */ 944, 137, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158374		- /* 490 */ 1028, 120, 120, 121, 121, 121, 121, 1530, 119, 119,
158375		- /* 500 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 403,
158376		- /* 510 */ 402, 241, 1176, 545, 501, 498, 497, 1468, 1143, 451,
158377		- /* 520 */ 267, 267, 513, 1540, 496, 142, 1176, 6, 406, 530,
158378		- /* 530 */ 194, 1143, 864, 560, 1143, 461, 182, 304, 554, 32,
158379		- /* 540 */ 379, 119, 119, 119, 119, 118, 118, 117, 117, 117,
	158531	+ /* 450 */ 121, 121, 121, 121, 217, 13, 13, 1176, 406, 568,
	158532	+ /* 460 */ 1400, 1228, 502, 137, 445, 168, 305, 545, 140, 1180,
	158533	+ /* 470 */ 424, 545, 1176, 1177, 1178, 1308, 544, 438, 437, 944,
	158534	+ /* 480 */ 513, 452, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
	158535	+ /* 490 */ 1028, 120, 120, 121, 121, 121, 121, 315, 119, 119,
	158536	+ /* 500 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 273,
	158537	+ /* 510 */ 273, 1143, 416, 1176, 1177, 1178, 543, 563, 1143, 304,
	158538	+ /* 520 */ 554, 1561, 560, 1207, 1143, 1207, 1180, 1143, 406, 530,
	158539	+ /* 530 */ 421, 1143, 864, 183, 1143, 143, 229, 562, 32, 71,
	158540	+ /* 540 */ 71, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158380	158541	/* 550 */ 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158381		- /* 560 */ 1028, 120, 120, 121, 121, 121, 121, 406, 1176, 1177,
158382		- /* 570 */ 1178, 857, 568, 1176, 1228, 925, 1176, 454, 361, 305,
158383		- /* 580 */ 189, 140, 1176, 1177, 1178, 519, 529, 404, 1308, 183,
	158542	+ /* 560 */ 1028, 120, 120, 121, 121, 121, 121, 406, 445, 241,
	158543	+ /* 570 */ 1176, 857, 501, 498, 497, 1176, 526, 189, 245, 538,
	158544	+ /* 580 */ 1539, 282, 496, 370, 6, 563, 529, 477, 5, 279,
158384	158545	/* 590 */ 1015, 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
158385		- /* 600 */ 120, 120, 121, 121, 121, 121, 1006, 16, 16, 370,
	158546	+ /* 600 */ 120, 120, 121, 121, 121, 121, 1006, 13, 13, 1414,
158386	158547	/* 610 */ 1005, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158387		- /* 620 */ 116, 441, 273, 273, 1537, 150, 1176, 98, 6, 1176,
158388		- /* 630 */ 1177, 1178, 1176, 1177, 1178, 560, 380, 406, 376, 438,
158389		- /* 640 */ 437, 1161, 1005, 1005, 1007, 1025, 1025, 1036, 1039, 229,
	158548	+ /* 620 */ 116, 441, 426, 273, 273, 1176, 1176, 1177, 1178, 1619,
	158549	+ /* 630 */ 392, 1176, 1177, 1178, 1176, 342, 560, 406, 525, 361,
	158550	+ /* 640 */ 430, 1161, 1005, 1005, 1007, 348, 411, 357, 1558, 488,
158390	158551	/* 650 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116,
158391	158552	/* 660 */ 441, 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
158392		- /* 670 */ 120, 120, 121, 121, 121, 121, 406, 1143, 1619, 392,
158393		- /* 680 */ 1016, 445, 1176, 1177, 1178, 1207, 525, 1207, 1530, 995,
158394		- /* 690 */ 1143, 304, 554, 1143, 5, 563, 543, 3, 361, 216,
	158553	+ /* 670 */ 120, 120, 121, 121, 121, 121, 406, 830, 831, 832,
	158554	+ /* 680 */ 1016, 1176, 1177, 1178, 396, 285, 148, 1312, 304, 554,
	158555	+ /* 690 */ 1176, 1177, 1178, 1467, 216, 3, 337, 137, 340, 560,
158395	158556	/* 700 */ 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120,
158396		- /* 710 */ 120, 121, 121, 121, 121, 143, 563, 13, 13, 1029,
	158557	+ /* 710 */ 120, 121, 121, 121, 121, 563, 504, 946, 273, 273,
158397	158558	/* 720 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116,
158398		- /* 730 */ 441, 1176, 426, 563, 1176, 563, 274, 274, 13, 13,
158399		- /* 740 */ 1078, 1176, 328, 457, 316, 147, 406, 211, 361, 560,
158400		- /* 750 */ 1000, 213, 511, 293, 477, 55, 55, 71, 71, 119,
	158559	+ /* 730 */ 441, 560, 1176, 427, 563, 451, 98, 13, 13, 259,
	158560	+ /* 740 */ 276, 356, 507, 351, 506, 246, 406, 361, 469, 1530,
	158561	+ /* 750 */ 1000, 347, 293, 304, 554, 1589, 71, 71, 889, 119,
158401	158562	/* 760 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 441,
158402	158563	/* 770 */ 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120,
158403		- /* 780 */ 120, 121, 121, 121, 121, 406, 455, 1176, 1177, 1178,
158404		- /* 790 */ 1176, 1177, 1178, 471, 526, 149, 404, 1176, 1177, 1178,
158405		- /* 800 */ 105, 270, 103, 563, 944, 563, 116, 441, 1530, 122,
	158564	+ /* 780 */ 120, 121, 121, 121, 121, 406, 1143, 1078, 1176, 1177,
	158565	+ /* 790 */ 1178, 416, 1080, 300, 150, 995, 1080, 361, 361, 1143,
	158566	+ /* 800 */ 361, 378, 1143, 477, 563, 244, 243, 242, 1278, 122,
158406	158567	/* 810 */ 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120,
158407		- /* 820 */ 121, 121, 121, 121, 945, 13, 13, 13, 13, 119,
	158568	+ /* 820 */ 121, 121, 121, 121, 563, 880, 13, 13, 483, 119,
158408	158569	/* 830 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 441,
158409		- /* 840 */ 191, 563, 192, 563, 416, 439, 439, 439, 1083, 1083,
158410		- /* 850 */ 485, 561, 285, 914, 914, 406, 462, 330, 1530, 830,
158411		- /* 860 */ 831, 832, 206, 71, 71, 71, 71, 286, 119, 119,
	158570	+ /* 840 */ 1176, 191, 540, 563, 147, 149, 13, 13, 328, 457,
	158571	+ /* 850 */ 316, 1083, 1083, 485, 1537, 406, 505, 1530, 6, 1514,
	158572	+ /* 860 */ 284, 192, 1277, 145, 881, 71, 71, 488, 119, 119,
158412	158573	/* 870 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 122,
158413	158574	/* 880 */ 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120,
158414		- /* 890 */ 121, 121, 121, 121, 563, 217, 563, 1122, 1617, 406,
158415		- /* 900 */ 300, 1617, 301, 416, 1278, 1473, 244, 243, 242, 1249,
158416		- /* 910 */ 412, 556, 412, 282, 842, 279, 71, 71, 71, 71,
158417		- /* 920 */ 944, 1415, 1473, 1475, 101, 113, 1200, 1200, 1035, 1038,
	158575	+ /* 890 */ 121, 121, 121, 121, 563, 471, 1176, 1177, 1178, 406,
	158576	+ /* 900 */ 852, 327, 301, 462, 330, 1516, 270, 1530, 1530, 944,
	158577	+ /* 910 */ 1531, 1307, 313, 9, 842, 251, 71, 71, 477, 428,
	158578	+ /* 920 */ 146, 488, 38, 945, 101, 113, 1200, 1200, 1035, 1038,
158418	158579	/* 930 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 119, 119,
158419		- /* 940 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 273,
158420		- /* 950 */ 273, 1099, 563, 436, 1143, 440, 563, 1122, 1618, 357,
158421		- /* 960 */ 1558, 1618, 560, 546, 488, 197, 1100, 1143, 378, 290,
158422		- /* 970 */ 1143, 1306, 284, 460, 71, 71, 1120, 405, 13, 13,
158423		- /* 980 */ 145, 1101, 119, 119, 119, 119, 118, 118, 117, 117,
158424		- /* 990 */ 117, 116, 441, 542, 104, 1473, 509, 273, 273, 294,
158425		- /* 1000 */ 1514, 294, 900, 273, 273, 273, 273, 563, 1503, 563,
158426		- /* 1010 */ 560, 545, 901, 464, 406, 1058, 560, 852, 560, 198,
158427		- /* 1020 */ 547, 1080, 920, 404, 1400, 1080, 146, 919, 38, 56,
158428		- /* 1030 */ 56, 15, 15, 563, 406, 12, 1120, 471, 122, 123,
	158580	+ /* 940 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 563,
	158581	+ /* 950 */ 1197, 1099, 563, 436, 563, 1533, 563, 852, 1122, 1617,
	158582	+ /* 960 */ 454, 290, 1617, 546, 251, 1303, 1100, 267, 267, 281,
	158583	+ /* 970 */ 404, 70, 70, 460, 71, 71, 71, 71, 13, 13,
	158584	+ /* 980 */ 560, 1101, 119, 119, 119, 119, 118, 118, 117, 117,
	158585	+ /* 990 */ 117, 116, 441, 542, 104, 273, 273, 273, 273, 1197,
	158586	+ /* 1000 */ 217, 1468, 900, 471, 450, 563, 1473, 1197, 560, 447,
	158587	+ /* 1010 */ 560, 545, 901, 440, 406, 1058, 292, 274, 274, 198,
	158588	+ /* 1020 */ 547, 450, 449, 1473, 1475, 944, 455, 56, 56, 410,
	158589	+ /* 1030 */ 560, 1122, 1618, 379, 406, 1618, 404, 1120, 122, 123,
158429	158590	/* 1040 */ 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120, 121,
158430		- /* 1050 */ 121, 121, 121, 1460, 406, 43, 43, 483, 122, 123,
	158591	+ /* 1050 */ 121, 121, 121, 1460, 406, 12, 1197, 1512, 122, 123,
158431	158592	/* 1060 */ 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120, 121,
158432		- /* 1070 */ 121, 121, 121, 563, 852, 9, 471, 251, 122, 111,
	158593	+ /* 1070 */ 121, 121, 121, 308, 471, 126, 359, 286, 122, 111,
158433	158594	/* 1080 */ 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120, 121,
158434		- /* 1090 */ 121, 121, 121, 563, 421, 57, 57, 119, 119, 119,
158435		- /* 1100 */ 119, 118, 118, 117, 117, 117, 116, 441, 1176, 493,
158436		- /* 1110 */ 563, 289, 1197, 478, 1516, 44, 44, 119, 119, 119,
158437		- /* 1120 */ 119, 118, 118, 117, 117, 117, 116, 441, 880, 563,
158438		- /* 1130 */ 536, 563, 58, 58, 488, 1414, 245, 119, 119, 119,
158439		- /* 1140 */ 119, 118, 118, 117, 117, 117, 116, 441, 563, 535,
158440		- /* 1150 */ 291, 59, 59, 60, 60, 438, 437, 406, 1154, 505,
158441		- /* 1160 */ 304, 554, 477, 1204, 1176, 1177, 1178, 881, 1206, 1197,
158442		- /* 1170 */ 61, 61, 1246, 357, 1558, 1538, 1205, 563, 1467, 6,
158443		- /* 1180 */ 1176, 488, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
158444		- /* 1190 */ 120, 120, 121, 121, 121, 121, 1400, 1143, 410, 62,
158445		- /* 1200 */ 62, 1207, 1099, 1207, 411, 447, 273, 273, 537, 1154,
158446		- /* 1210 */ 1143, 108, 555, 1143, 4, 391, 1220, 1100, 1512, 560,
158447		- /* 1220 */ 347, 516, 428, 548, 308, 1307, 1536, 1077, 558, 1077,
158448		- /* 1230 */ 6, 488, 1101, 1400, 488, 309, 1176, 1177, 1178, 563,
	158595	+ /* 1090 */ 121, 121, 121, 309, 450, 471, 1473, 119, 119, 119,
	158596	+ /* 1100 */ 119, 118, 118, 117, 117, 117, 116, 441, 1176, 563,
	158597	+ /* 1110 */ 1120, 482, 563, 312, 433, 479, 197, 119, 119, 119,
	158598	+ /* 1120 */ 119, 118, 118, 117, 117, 117, 116, 441, 405, 12,
	158599	+ /* 1130 */ 536, 15, 15, 478, 43, 43, 509, 119, 119, 119,
	158600	+ /* 1140 */ 119, 118, 118, 117, 117, 117, 116, 441, 289, 535,
	158601	+ /* 1150 */ 294, 563, 294, 391, 1220, 438, 437, 406, 1154, 403,
	158602	+ /* 1160 */ 402, 1400, 920, 1204, 1176, 1177, 1178, 919, 1206, 291,
	158603	+ /* 1170 */ 1306, 1249, 412, 57, 57, 488, 1205, 563, 556, 412,
	158604	+ /* 1180 */ 1176, 1344, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
	158605	+ /* 1190 */ 120, 120, 121, 121, 121, 121, 1400, 1143, 563, 44,
	158606	+ /* 1200 */ 44, 1207, 194, 1207, 273, 273, 1400, 461, 537, 1154,
	158607	+ /* 1210 */ 1143, 108, 555, 1143, 4, 391, 1121, 560, 1538, 335,
	158608	+ /* 1220 */ 58, 58, 6, 1246, 1099, 380, 1400, 376, 558, 1536,
	158609	+ /* 1230 */ 563, 422, 1221, 6, 304, 554, 1176, 1177, 1178, 1100,
158449	158610	/* 1240 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116,
158450		- /* 1250 */ 441, 442, 278, 551, 563, 273, 273, 273, 273, 563,
158451		- /* 1260 */ 327, 45, 45, 552, 563, 528, 422, 563, 560, 1400,
158452		- /* 1270 */ 560, 108, 555, 137, 4, 1303, 46, 46, 335, 563,
158453		- /* 1280 */ 482, 47, 47, 477, 479, 307, 49, 49, 558, 50,
158454		- /* 1290 */ 50, 563, 1015, 563, 1221, 563, 1400, 563, 106, 106,
158455		- /* 1300 */ 8, 63, 63, 423, 563, 107, 312, 442, 565, 564,
158456		- /* 1310 */ 563, 442, 1005, 64, 64, 65, 65, 14, 14, 66,
158457		- /* 1320 */ 66, 391, 1121, 552, 1312, 1180, 128, 128, 563, 304,
158458		- /* 1330 */ 554, 563, 67, 67, 563, 359, 560, 532, 563, 484,
158459		- /* 1340 */ 563, 1196, 531, 222, 1005, 1005, 1007, 1008, 27, 522,
158460		- /* 1350 */ 52, 52, 1015, 68, 68, 563, 69, 69, 106, 106,
158461		- /* 1360 */ 53, 53, 156, 156, 563, 107, 434, 442, 565, 564,
158462		- /* 1370 */ 272, 215, 1005, 425, 563, 359, 563, 157, 157, 563,
158463		- /* 1380 */ 1535, 292, 1180, 98, 6, 1344, 76, 76, 1215, 475,
158464		- /* 1390 */ 413, 169, 226, 563, 245, 563, 54, 54, 72, 72,
158465		- /* 1400 */ 1221, 129, 129, 1343, 1005, 1005, 1007, 1008, 27, 1563,
158466		- /* 1410 */ 1165, 444, 456, 433, 277, 73, 73, 130, 130, 389,
158467		- /* 1420 */ 389, 388, 262, 386, 1165, 444, 839, 1519, 277, 108,
158468		- /* 1430 */ 555, 321, 4, 389, 389, 388, 262, 386, 563, 223,
158469		- /* 1440 */ 839, 311, 468, 84, 202, 523, 558, 1492, 303, 310,
158470		- /* 1450 */ 563, 110, 404, 223, 563, 311, 206, 30, 404, 277,
158471		- /* 1460 */ 131, 131, 411, 310, 389, 389, 388, 262, 386, 442,
158472		- /* 1470 */ 920, 839, 127, 127, 563, 919, 155, 155, 1491, 225,
158473		- /* 1480 */ 563, 552, 871, 563, 223, 476, 311, 161, 31, 563,
158474		- /* 1490 */ 135, 563, 480, 225, 310, 532, 154, 154, 332, 17,
158475		- /* 1500 */ 533, 161, 136, 136, 135, 134, 134, 224, 228, 355,
158476		- /* 1510 */ 1015, 132, 132, 133, 133, 1589, 106, 106, 889, 354,
158477		- /* 1520 */ 563, 224, 563, 107, 225, 442, 565, 564, 1117, 275,
158478		- /* 1530 */ 1005, 393, 161, 518, 563, 135, 108, 555, 417, 4,
158479		- /* 1540 */ 1340, 407, 75, 75, 77, 77, 304, 554, 867, 563,
158480		- /* 1550 */ 336, 563, 224, 558, 463, 407, 74, 74, 465, 1065,
158481		- /* 1560 */ 304, 554, 1005, 1005, 1007, 1008, 27, 962, 963, 543,
158482		- /* 1570 */ 448, 42, 42, 48, 48, 326, 442, 325, 98, 997,
158483		- /* 1580 */ 470, 287, 250, 250, 448, 1009, 407, 472, 552, 339,
158484		- /* 1590 */ 250, 304, 554, 879, 878, 331, 108, 555, 98, 4,
158485		- /* 1600 */ 1277, 494, 532, 345, 247, 867, 98, 531, 341, 886,
158486		- /* 1610 */ 887, 1126, 1076, 558, 1076, 448, 1065, 1015, 1061, 953,
158487		- /* 1620 */ 343, 247, 250, 106, 106, 1291, 917, 1276, 850, 110,
158488		- /* 1630 */ 107, 144, 442, 565, 564, 918, 442, 1005, 110, 1275,
158489		- /* 1640 */ 350, 360, 1009, 1331, 1352, 299, 1399, 1577, 552, 1327,
158490		- /* 1650 */ 1552, 550, 1338, 549, 1405, 1256, 1248, 1237, 1236, 1238,
158491		- /* 1660 */ 1571, 489, 265, 200, 1324, 363, 365, 367, 11, 1005,
158492		- /* 1670 */ 1005, 1007, 1008, 27, 390, 221, 1386, 1015, 280, 1391,
158493		- /* 1680 */ 1381, 208, 323, 106, 106, 924, 1374, 453, 283, 324,
158494		- /* 1690 */ 107, 474, 442, 565, 564, 1390, 499, 1005, 212, 288,
158495		- /* 1700 */ 1274, 397, 353, 108, 555, 195, 4, 1464, 369, 1463,
158496		- /* 1710 */ 1574, 1215, 1212, 329, 553, 171, 207, 383, 1511, 196,
158497		- /* 1720 */ 558, 254, 1509, 415, 100, 555, 83, 4, 204, 1005,
158498		- /* 1730 */ 1005, 1007, 1008, 27, 219, 79, 82, 1469, 180, 166,
158499		- /* 1740 */ 173, 558, 458, 442, 175, 176, 177, 178, 35, 1387,
158500		- /* 1750 */ 492, 459, 231, 1395, 96, 552, 1393, 1392, 395, 184,
158501		- /* 1760 */ 481, 466, 36, 235, 442, 89, 398, 266, 487, 1480,
158502		- /* 1770 */ 1458, 237, 188, 338, 508, 429, 552, 490, 400, 238,
158503		- /* 1780 */ 334, 1239, 239, 1294, 1015, 1293, 1292, 1285, 91, 871,
158504		- /* 1790 */ 106, 106, 213, 431, 1588, 432, 524, 107, 517, 442,
158505		- /* 1800 */ 565, 564, 401, 1264, 1005, 1015, 1263, 1587, 352, 1262,
158506		- /* 1810 */ 1557, 106, 106, 1586, 1284, 297, 298, 358, 107, 1335,
158507		- /* 1820 */ 442, 565, 564, 95, 362, 1005, 253, 252, 435, 125,
158508		- /* 1830 */ 543, 10, 1444, 1543, 377, 1542, 1005, 1005, 1007, 1008,
158509		- /* 1840 */ 27, 302, 102, 97, 527, 1336, 260, 1317, 364, 1245,
158510		- /* 1850 */ 1334, 34, 566, 1171, 366, 381, 375, 1005, 1005, 1007,
158511		- /* 1860 */ 1008, 27, 1333, 1359, 368, 1316, 199, 382, 261, 263,
158512		- /* 1870 */ 264, 1358, 158, 1496, 141, 1497, 1495, 567, 1234, 1229,
158513		- /* 1880 */ 1494, 295, 159, 209, 210, 78, 826, 443, 201, 306,
158514		- /* 1890 */ 220, 1075, 138, 1073, 160, 314, 162, 172, 1196, 174,
158515		- /* 1900 */ 903, 227, 230, 322, 1089, 179, 163, 164, 418, 85,
158516		- /* 1910 */ 420, 181, 170, 408, 409, 86, 87, 165, 88, 1092,
158517		- /* 1920 */ 232, 233, 1088, 151, 18, 234, 1081, 250, 333, 185,
158518		- /* 1930 */ 1209, 486, 236, 186, 37, 841, 491, 354, 240, 346,
158519		- /* 1940 */ 503, 187, 90, 167, 19, 495, 20, 869, 500, 349,
158520		- /* 1950 */ 92, 882, 296, 152, 93, 510, 1127, 1159, 153, 1041,
158521		- /* 1960 */ 214, 1128, 39, 94, 269, 271, 952, 190, 947, 110,
158522		- /* 1970 */ 1149, 1145, 1153, 249, 1133, 1147, 7, 33, 21, 193,
158523		- /* 1980 */ 22, 23, 24, 25, 1152, 539, 98, 1056, 26, 1042,
158524		- /* 1990 */ 1040, 1044, 1098, 1045, 1097, 256, 255, 28, 40, 387,
158525		- /* 2000 */ 1010, 851, 109, 29, 1167, 559, 384, 257, 913, 258,
158526		- /* 2010 */ 1166, 1579, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1578,
	158611	+ /* 1250 */ 441, 442, 59, 59, 1101, 516, 1535, 273, 273, 563,
	158612	+ /* 1260 */ 6, 563, 110, 552, 563, 528, 423, 413, 169, 548,
	158613	+ /* 1270 */ 560, 108, 555, 137, 4, 551, 484, 272, 215, 222,
	158614	+ /* 1280 */ 211, 60, 60, 61, 61, 98, 62, 62, 558, 273,
	158615	+ /* 1290 */ 273, 563, 1015, 467, 1221, 563, 434, 563, 106, 106,
	158616	+ /* 1300 */ 8, 920, 560, 273, 273, 107, 919, 442, 565, 564,
	158617	+ /* 1310 */ 563, 442, 1005, 45, 45, 464, 560, 46, 46, 47,
	158618	+ /* 1320 */ 47, 84, 202, 552, 1215, 404, 468, 563, 205, 304,
	158619	+ /* 1330 */ 554, 563, 49, 49, 563, 522, 404, 532, 563, 867,
	158620	+ /* 1340 */ 563, 105, 531, 103, 1005, 1005, 1007, 1008, 27, 50,
	158621	+ /* 1350 */ 50, 563, 1015, 63, 63, 475, 64, 64, 106, 106,
	158622	+ /* 1360 */ 65, 65, 14, 14, 17, 107, 563, 442, 565, 564,
	158623	+ /* 1370 */ 563, 303, 1005, 66, 66, 563, 226, 563, 959, 563,
	158624	+ /* 1380 */ 543, 404, 1196, 1343, 871, 278, 960, 456, 128, 128,
	158625	+ /* 1390 */ 563, 1065, 67, 67, 563, 206, 867, 52, 52, 68,
	158626	+ /* 1400 */ 68, 69, 69, 417, 1005, 1005, 1007, 1008, 27, 1563,
	158627	+ /* 1410 */ 1165, 444, 53, 53, 277, 1519, 156, 156, 307, 389,
	158628	+ /* 1420 */ 389, 388, 262, 386, 1165, 444, 839, 321, 277, 108,
	158629	+ /* 1430 */ 555, 523, 4, 389, 389, 388, 262, 386, 563, 223,
	158630	+ /* 1440 */ 839, 311, 326, 1492, 1117, 98, 558, 393, 1065, 310,
	158631	+ /* 1450 */ 563, 476, 563, 223, 563, 311, 879, 878, 1009, 277,
	158632	+ /* 1460 */ 157, 157, 463, 310, 389, 389, 388, 262, 386, 442,
	158633	+ /* 1470 */ 518, 839, 76, 76, 54, 54, 72, 72, 355, 225,
	158634	+ /* 1480 */ 563, 552, 275, 563, 223, 325, 311, 161, 354, 465,
	158635	+ /* 1490 */ 135, 563, 228, 225, 310, 532, 563, 206, 886, 887,
	158636	+ /* 1500 */ 533, 161, 129, 129, 135, 73, 73, 224, 962, 963,
	158637	+ /* 1510 */ 1015, 563, 287, 130, 130, 1009, 106, 106, 131, 131,
	158638	+ /* 1520 */ 563, 224, 563, 107, 225, 442, 565, 564, 997, 1276,
	158639	+ /* 1530 */ 1005, 250, 161, 127, 127, 135, 108, 555, 1077, 4,
	158640	+ /* 1540 */ 1077, 407, 155, 155, 154, 154, 304, 554, 1126, 563,
	158641	+ /* 1550 */ 1331, 563, 224, 558, 470, 407, 563, 250, 563, 1491,
	158642	+ /* 1560 */ 304, 554, 1005, 1005, 1007, 1008, 27, 563, 480, 332,
	158643	+ /* 1570 */ 448, 136, 136, 134, 134, 1340, 442, 336, 132, 132,
	158644	+ /* 1580 */ 133, 133, 563, 1076, 448, 1076, 407, 563, 552, 75,
	158645	+ /* 1590 */ 75, 304, 554, 339, 341, 343, 108, 555, 563, 4,
	158646	+ /* 1600 */ 1577, 299, 532, 563, 77, 77, 1291, 531, 472, 74,
	158647	+ /* 1610 */ 74, 250, 1275, 558, 350, 448, 331, 1015, 360, 98,
	158648	+ /* 1620 */ 42, 42, 1352, 106, 106, 48, 48, 1399, 494, 1327,
	158649	+ /* 1630 */ 107, 247, 442, 565, 564, 345, 442, 1005, 98, 1061,
	158650	+ /* 1640 */ 953, 917, 247, 250, 110, 1552, 550, 850, 552, 918,
	158651	+ /* 1650 */ 144, 1338, 110, 549, 1405, 1256, 1248, 1237, 1236, 1238,
	158652	+ /* 1660 */ 1571, 1324, 208, 390, 489, 265, 363, 200, 365, 1005,
	158653	+ /* 1670 */ 1005, 1007, 1008, 27, 11, 280, 221, 1015, 323, 474,
	158654	+ /* 1680 */ 1274, 367, 212, 106, 106, 924, 1386, 324, 288, 1381,
	158655	+ /* 1690 */ 107, 453, 442, 565, 564, 283, 329, 1005, 1391, 499,
	158656	+ /* 1700 */ 353, 1374, 1464, 108, 555, 1463, 4, 1574, 1390, 397,
	158657	+ /* 1710 */ 1215, 171, 254, 369, 383, 207, 195, 196, 1511, 553,
	158658	+ /* 1720 */ 558, 1509, 415, 1212, 100, 555, 83, 4, 204, 1005,
	158659	+ /* 1730 */ 1005, 1007, 1008, 27, 180, 166, 173, 219, 79, 82,
	158660	+ /* 1740 */ 458, 558, 175, 442, 35, 1387, 176, 459, 177, 178,
	158661	+ /* 1750 */ 492, 231, 96, 1469, 395, 552, 1393, 1392, 36, 466,
	158662	+ /* 1760 */ 1395, 184, 398, 481, 442, 1458, 235, 89, 1480, 487,
	158663	+ /* 1770 */ 266, 334, 237, 188, 490, 400, 552, 338, 238, 508,
	158664	+ /* 1780 */ 1239, 239, 1294, 1293, 1015, 1292, 1285, 429, 91, 871,
	158665	+ /* 1790 */ 106, 106, 1588, 213, 401, 1587, 431, 107, 1264, 442,
	158666	+ /* 1800 */ 565, 564, 1263, 352, 1005, 1015, 1262, 1586, 1557, 517,
	158667	+ /* 1810 */ 432, 106, 106, 1284, 297, 298, 358, 524, 107, 1335,
	158668	+ /* 1820 */ 442, 565, 564, 95, 1336, 1005, 252, 253, 435, 125,
	158669	+ /* 1830 */ 543, 1543, 10, 1444, 377, 1542, 1005, 1005, 1007, 1008,
	158670	+ /* 1840 */ 27, 97, 527, 375, 362, 102, 260, 364, 381, 1317,
	158671	+ /* 1850 */ 382, 1334, 366, 1245, 1333, 1316, 368, 1005, 1005, 1007,
	158672	+ /* 1860 */ 1008, 27, 1359, 1358, 34, 199, 1171, 566, 261, 263,
	158673	+ /* 1870 */ 264, 567, 1234, 158, 1229, 141, 295, 159, 1496, 302,
	158674	+ /* 1880 */ 1497, 1495, 1494, 160, 826, 209, 443, 201, 306, 210,
	158675	+ /* 1890 */ 78, 220, 1075, 138, 1073, 314, 162, 172, 1196, 227,
	158676	+ /* 1900 */ 174, 903, 322, 230, 1089, 179, 163, 164, 418, 408,
	158677	+ /* 1910 */ 409, 170, 181, 85, 86, 420, 87, 165, 1092, 88,
	158678	+ /* 1920 */ 233, 232, 1088, 151, 18, 234, 1081, 250, 333, 1209,
	158679	+ /* 1930 */ 185, 486, 236, 186, 37, 841, 491, 354, 240, 346,
	158680	+ /* 1940 */ 495, 187, 90, 869, 19, 20, 500, 503, 349, 92,
	158681	+ /* 1950 */ 167, 152, 296, 882, 93, 510, 94, 1159, 153, 1041,
	158682	+ /* 1960 */ 1128, 39, 214, 269, 1127, 271, 249, 952, 190, 947,
	158683	+ /* 1970 */ 110, 1149, 21, 7, 1153, 22, 1145, 23, 1147, 24,
	158684	+ /* 1980 */ 1133, 25, 1152, 33, 539, 193, 26, 1056, 98, 1042,
	158685	+ /* 1990 */ 1040, 1044, 1098, 1045, 1097, 256, 255, 28, 40, 257,
	158686	+ /* 2000 */ 1010, 851, 109, 29, 913, 559, 384, 387, 258, 1167,
	158687	+ /* 2010 */ 1166, 1225, 1225, 1225, 1579, 1225, 1225, 1225, 1225, 1225,
	158688	+ /* 2020 */ 1225, 1225, 1578,
158527	158689	};
158528	158690	static const YYCODETYPE yy_lookahead[] = {
158529		- /* 0 */ 191, 220, 191, 222, 191, 191, 271, 272, 273, 216,
158530		- /* 10 */ 191, 230, 216, 191, 191, 191, 271, 272, 273, 19,
158531		- /* 20 */ 232, 233, 213, 214, 213, 214, 202, 292, 202, 232,
158532		- /* 30 */ 233, 31, 213, 214, 213, 213, 214, 213, 214, 39,
158533		- /* 40 */ 207, 208, 209, 43, 44, 45, 46, 47, 48, 49,
158534		- /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 235, 19,
158535		- /* 60 */ 236, 237, 236, 237, 271, 272, 273, 271, 272, 273,
158536		- /* 70 */ 191, 210, 250, 249, 250, 249, 213, 191, 199, 253,
158537		- /* 80 */ 254, 259, 203, 43, 44, 45, 46, 47, 48, 49,
158538		- /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 191, 213,
158539		- /* 100 */ 214, 213, 102, 103, 104, 105, 106, 107, 108, 109,
158540		- /* 110 */ 110, 111, 112, 59, 228, 301, 293, 81, 305, 306,
158541		- /* 120 */ 311, 312, 311, 310, 313, 59, 86, 212, 88, 19,
158542		- /* 130 */ 311, 312, 271, 272, 273, 220, 26, 112, 54, 55,
	158691	+ /* 0 */ 192, 221, 192, 223, 192, 214, 272, 273, 274, 217,
	158692	+ /* 10 */ 192, 231, 217, 192, 192, 192, 272, 273, 274, 19,
	158693	+ /* 20 */ 233, 234, 214, 215, 214, 215, 203, 293, 203, 233,
	158694	+ /* 30 */ 234, 31, 214, 215, 214, 214, 215, 214, 215, 39,
	158695	+ /* 40 */ 208, 209, 210, 43, 44, 45, 46, 47, 48, 49,
	158696	+ /* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 236, 19,
	158697	+ /* 60 */ 237, 238, 237, 238, 272, 273, 274, 272, 273, 274,
	158698	+ /* 70 */ 192, 211, 251, 250, 251, 250, 26, 192, 200, 254,
	158699	+ /* 80 */ 255, 260, 204, 43, 44, 45, 46, 47, 48, 49,
	158700	+ /* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 192, 214,
	158701	+ /* 100 */ 215, 214, 102, 103, 104, 105, 106, 107, 108, 109,
	158702	+ /* 110 */ 110, 111, 112, 59, 229, 192, 294, 16, 306, 307,
	158703	+ /* 120 */ 312, 313, 312, 311, 314, 59, 86, 204, 88, 19,
	158704	+ /* 130 */ 312, 313, 272, 273, 274, 271, 26, 22, 54, 55,
158543	158705	/* 140 */ 56, 57, 102, 103, 104, 105, 106, 107, 108, 109,
158544	158706	/* 150 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49,
158545		- /* 160 */ 50, 51, 52, 53, 54, 55, 56, 57, 191, 115,
158546		- /* 170 */ 116, 117, 118, 137, 138, 121, 122, 123, 191, 69,
158547		- /* 180 */ 203, 115, 116, 117, 59, 131, 102, 103, 104, 105,
158548		- /* 190 */ 106, 107, 108, 109, 110, 111, 112, 72, 191, 19,
	158707	+ /* 160 */ 50, 51, 52, 53, 54, 55, 56, 57, 53, 115,
	158708	+ /* 170 */ 116, 117, 118, 309, 310, 121, 122, 123, 77, 69,
	158709	+ /* 180 */ 79, 115, 116, 117, 59, 131, 102, 103, 104, 105,
	158710	+ /* 190 */ 106, 107, 108, 109, 110, 111, 112, 72, 148, 19,
158549	158711	/* 200 */ 54, 55, 56, 57, 58, 108, 109, 110, 111, 112,
158550		- /* 210 */ 303, 304, 102, 103, 104, 105, 106, 107, 108, 109,
	158712	+ /* 210 */ 304, 305, 102, 103, 104, 105, 106, 107, 108, 109,
158551	158713	/* 220 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49,
158552		- /* 230 */ 50, 51, 52, 53, 54, 55, 56, 57, 19, 16,
158553		- /* 240 */ 115, 116, 117, 24, 16, 227, 202, 67, 102, 103,
158554		- /* 250 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 59,
158555		- /* 260 */ 26, 191, 43, 44, 45, 46, 47, 48, 49, 50,
158556		- /* 270 */ 51, 52, 53, 54, 55, 56, 57, 24, 208, 209,
158557		- /* 280 */ 236, 237, 102, 103, 104, 105, 106, 107, 108, 109,
158558		- /* 290 */ 110, 111, 112, 249, 183, 184, 185, 186, 187, 188,
158559		- /* 300 */ 77, 59, 79, 191, 193, 77, 195, 79, 19, 19,
158560		- /* 310 */ 266, 304, 59, 202, 24, 115, 116, 117, 191, 127,
	158714	+ /* 230 */ 50, 51, 52, 53, 54, 55, 56, 57, 19, 112,
	158715	+ /* 240 */ 115, 116, 117, 24, 208, 209, 210, 67, 102, 103,
	158716	+ /* 250 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 192,
	158717	+ /* 260 */ 59, 160, 43, 44, 45, 46, 47, 48, 49, 50,
	158718	+ /* 270 */ 51, 52, 53, 54, 55, 56, 57, 19, 46, 47,
	158719	+ /* 280 */ 48, 49, 102, 103, 104, 105, 106, 107, 108, 109,
	158720	+ /* 290 */ 110, 111, 112, 213, 73, 184, 185, 186, 187, 188,
	158721	+ /* 300 */ 189, 221, 81, 236, 46, 194, 192, 196, 19, 59,
	158722	+ /* 310 */ 133, 59, 135, 136, 203, 192, 115, 116, 117, 127,
158561	158723	/* 320 */ 128, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158562	158724	/* 330 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50,
158563		- /* 340 */ 51, 52, 53, 54, 55, 56, 57, 236, 237, 191,
158564		- /* 350 */ 150, 281, 191, 185, 186, 187, 188, 115, 116, 117,
158565		- /* 360 */ 249, 193, 191, 195, 26, 73, 59, 191, 114, 116,
158566		- /* 370 */ 202, 213, 214, 81, 263, 106, 107, 108, 109, 110,
158567		- /* 380 */ 111, 112, 148, 160, 142, 95, 228, 191, 191, 213,
158568		- /* 390 */ 214, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158569		- /* 400 */ 111, 112, 112, 149, 236, 237, 295, 100, 118, 119,
158570		- /* 410 */ 120, 121, 122, 123, 124, 19, 31, 249, 126, 23,
158571		- /* 420 */ 130, 260, 115, 116, 39, 22, 250, 120, 191, 137,
158572		- /* 430 */ 138, 263, 305, 306, 238, 259, 265, 310, 149, 43,
	158725	+ /* 340 */ 51, 52, 53, 54, 55, 56, 57, 126, 237, 238,
	158726	+ /* 350 */ 100, 150, 120, 230, 186, 187, 188, 189, 137, 138,
	158727	+ /* 360 */ 108, 250, 194, 26, 196, 115, 116, 115, 116, 117,
	158728	+ /* 370 */ 120, 203, 114, 164, 165, 264, 102, 103, 104, 105,
	158729	+ /* 380 */ 106, 107, 108, 109, 110, 111, 112, 192, 130, 111,
	158730	+ /* 390 */ 112, 102, 103, 104, 105, 106, 107, 108, 109, 110,
	158731	+ /* 400 */ 111, 112, 152, 153, 154, 237, 238, 296, 192, 214,
	158732	+ /* 410 */ 215, 228, 192, 307, 192, 19, 59, 311, 250, 23,
	158733	+ /* 420 */ 22, 106, 107, 108, 109, 110, 111, 112, 192, 72,
	158734	+ /* 430 */ 214, 215, 264, 192, 214, 215, 214, 215, 149, 43,
158573	158735	/* 440 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
158574		- /* 450 */ 54, 55, 56, 57, 191, 117, 191, 210, 19, 152,
158575		- /* 460 */ 153, 154, 23, 295, 102, 103, 104, 105, 106, 107,
158576		- /* 470 */ 108, 109, 110, 111, 112, 266, 213, 214, 213, 214,
158577		- /* 480 */ 142, 81, 43, 44, 45, 46, 47, 48, 49, 50,
158578		- /* 490 */ 51, 52, 53, 54, 55, 56, 57, 301, 102, 103,
158579		- /* 500 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 106,
158580		- /* 510 */ 107, 118, 59, 250, 121, 122, 123, 280, 76, 119,
158581		- /* 520 */ 236, 237, 259, 306, 131, 72, 59, 310, 19, 87,
158582		- /* 530 */ 283, 89, 23, 249, 92, 288, 22, 137, 138, 22,
158583		- /* 540 */ 275, 102, 103, 104, 105, 106, 107, 108, 109, 110,
	158736	+ /* 450 */ 54, 55, 56, 57, 117, 214, 215, 59, 19, 187,
	158737	+ /* 460 */ 192, 189, 23, 81, 296, 192, 194, 251, 196, 59,
	158738	+ /* 470 */ 229, 251, 115, 116, 117, 203, 260, 106, 107, 142,
	158739	+ /* 480 */ 260, 267, 43, 44, 45, 46, 47, 48, 49, 50,
	158740	+ /* 490 */ 51, 52, 53, 54, 55, 56, 57, 261, 102, 103,
	158741	+ /* 500 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 237,
	158742	+ /* 510 */ 238, 76, 192, 115, 116, 117, 144, 192, 76, 137,
	158743	+ /* 520 */ 138, 192, 250, 152, 89, 154, 116, 92, 19, 87,
	158744	+ /* 530 */ 262, 89, 23, 22, 92, 163, 264, 192, 22, 214,
	158745	+ /* 540 */ 215, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158584	158746	/* 550 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50,
158585		- /* 560 */ 51, 52, 53, 54, 55, 56, 57, 19, 115, 116,
158586		- /* 570 */ 117, 23, 186, 59, 188, 108, 59, 241, 191, 193,
158587		- /* 580 */ 26, 195, 115, 116, 117, 191, 144, 251, 202, 22,
	158747	+ /* 560 */ 51, 52, 53, 54, 55, 56, 57, 19, 296, 118,
	158748	+ /* 570 */ 59, 23, 121, 122, 123, 59, 251, 26, 46, 306,
	158749	+ /* 580 */ 307, 261, 131, 192, 311, 192, 144, 192, 22, 203,
158588	158750	/* 590 */ 100, 43, 44, 45, 46, 47, 48, 49, 50, 51,
158589		- /* 600 */ 52, 53, 54, 55, 56, 57, 116, 213, 214, 191,
	158751	+ /* 600 */ 52, 53, 54, 55, 56, 57, 116, 214, 215, 271,
158590	158752	/* 610 */ 120, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158591		- /* 620 */ 111, 112, 236, 237, 306, 238, 59, 26, 310, 115,
158592		- /* 630 */ 116, 117, 115, 116, 117, 249, 246, 19, 248, 106,
158593		- /* 640 */ 107, 23, 152, 153, 154, 46, 47, 48, 49, 263,
	158753	+ /* 620 */ 111, 112, 229, 237, 238, 59, 115, 116, 117, 299,
	158754	+ /* 630 */ 300, 115, 116, 117, 59, 16, 250, 19, 192, 192,
	158755	+ /* 640 */ 19, 23, 152, 153, 154, 24, 114, 309, 310, 192,
158594	158756	/* 650 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
158595	158757	/* 660 */ 112, 43, 44, 45, 46, 47, 48, 49, 50, 51,
158596		- /* 670 */ 52, 53, 54, 55, 56, 57, 19, 76, 298, 299,
158597		- /* 680 */ 23, 295, 115, 116, 117, 152, 191, 154, 301, 73,
158598		- /* 690 */ 89, 137, 138, 92, 22, 191, 144, 22, 191, 191,
	158758	+ /* 670 */ 52, 53, 54, 55, 56, 57, 19, 7, 8, 9,
	158759	+ /* 680 */ 23, 115, 116, 117, 203, 290, 239, 238, 137, 138,
	158760	+ /* 690 */ 115, 116, 117, 236, 192, 22, 77, 81, 79, 250,
158599	158761	/* 700 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
158600		- /* 710 */ 53, 54, 55, 56, 57, 163, 191, 213, 214, 120,
	158762	+ /* 710 */ 53, 54, 55, 56, 57, 192, 95, 142, 237, 238,
158601	158763	/* 720 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
158602		- /* 730 */ 112, 59, 228, 191, 59, 191, 236, 237, 213, 214,
158603		- /* 740 */ 11, 59, 126, 127, 128, 238, 19, 26, 191, 249,
158604		- /* 750 */ 23, 164, 165, 228, 191, 213, 214, 213, 214, 102,
	158764	+ /* 730 */ 112, 250, 59, 112, 192, 119, 26, 214, 215, 118,
	158765	+ /* 740 */ 119, 120, 121, 122, 123, 124, 19, 192, 267, 302,
	158766	+ /* 750 */ 23, 130, 229, 137, 138, 23, 214, 215, 26, 102,
158605	158767	/* 760 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
158606	158768	/* 770 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
158607		- /* 780 */ 53, 54, 55, 56, 57, 19, 241, 115, 116, 117,
158608		- /* 790 */ 115, 116, 117, 191, 250, 238, 251, 115, 116, 117,
158609		- /* 800 */ 157, 23, 159, 191, 26, 191, 111, 112, 301, 43,
	158769	+ /* 780 */ 53, 54, 55, 56, 57, 19, 76, 11, 115, 116,
	158770	+ /* 790 */ 117, 192, 29, 251, 239, 73, 33, 192, 192, 89,
	158771	+ /* 800 */ 192, 192, 92, 192, 192, 126, 127, 128, 224, 43,
158610	158772	/* 810 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
158611		- /* 820 */ 54, 55, 56, 57, 142, 213, 214, 213, 214, 102,
	158773	+ /* 820 */ 54, 55, 56, 57, 192, 35, 214, 215, 65, 102,
158612	158774	/* 830 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
158613		- /* 840 */ 228, 191, 228, 191, 191, 207, 208, 209, 126, 127,
158614		- /* 850 */ 128, 133, 289, 135, 136, 19, 127, 128, 301, 7,
158615		- /* 860 */ 8, 9, 141, 213, 214, 213, 214, 265, 102, 103,
	158775	+ /* 840 */ 59, 229, 192, 192, 239, 239, 214, 215, 126, 127,
	158776	+ /* 850 */ 128, 126, 127, 128, 307, 19, 66, 302, 311, 192,
	158777	+ /* 860 */ 261, 229, 224, 22, 74, 214, 215, 192, 102, 103,
158616	158778	/* 870 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 43,
158617	158779	/* 880 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
158618		- /* 890 */ 54, 55, 56, 57, 191, 117, 191, 22, 23, 19,
158619		- /* 900 */ 250, 26, 250, 191, 223, 191, 126, 127, 128, 205,
158620		- /* 910 */ 206, 205, 206, 260, 21, 202, 213, 214, 213, 214,
158621		- /* 920 */ 142, 270, 208, 209, 158, 45, 46, 47, 48, 49,
	158780	+ /* 890 */ 54, 55, 56, 57, 192, 192, 115, 116, 117, 19,
	158781	+ /* 900 */ 59, 290, 251, 127, 128, 192, 23, 302, 302, 26,
	158782	+ /* 910 */ 302, 236, 192, 22, 21, 24, 214, 215, 192, 129,
	158783	+ /* 920 */ 22, 192, 24, 142, 158, 45, 46, 47, 48, 49,
158622	158784	/* 930 */ 50, 51, 52, 53, 54, 55, 56, 57, 102, 103,
158623		- /* 940 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 236,
158624		- /* 950 */ 237, 12, 191, 250, 76, 250, 191, 22, 23, 308,
158625		- /* 960 */ 309, 26, 249, 202, 191, 191, 27, 89, 191, 202,
158626		- /* 970 */ 92, 202, 260, 80, 213, 214, 101, 203, 213, 214,
158627		- /* 980 */ 22, 42, 102, 103, 104, 105, 106, 107, 108, 109,
158628		- /* 990 */ 110, 111, 112, 228, 158, 281, 108, 236, 237, 225,
158629		- /* 1000 */ 191, 227, 63, 236, 237, 236, 237, 191, 235, 191,
158630		- /* 1010 */ 249, 250, 73, 241, 19, 122, 249, 59, 249, 24,
158631		- /* 1020 */ 259, 29, 134, 251, 191, 33, 22, 139, 24, 213,
158632		- /* 1030 */ 214, 213, 214, 191, 19, 210, 101, 191, 43, 44,
	158785	+ /* 940 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 192,
	158786	+ /* 950 */ 59, 12, 192, 251, 192, 305, 192, 116, 22, 23,
	158787	+ /* 960 */ 242, 203, 26, 203, 24, 236, 27, 237, 238, 266,
	158788	+ /* 970 */ 252, 214, 215, 80, 214, 215, 214, 215, 214, 215,
	158789	+ /* 980 */ 250, 42, 102, 103, 104, 105, 106, 107, 108, 109,
	158790	+ /* 990 */ 110, 111, 112, 229, 158, 237, 238, 237, 238, 59,
	158791	+ /* 1000 */ 117, 281, 63, 192, 192, 192, 192, 116, 250, 192,
	158792	+ /* 1010 */ 250, 251, 73, 251, 19, 122, 290, 237, 238, 24,
	158793	+ /* 1020 */ 260, 209, 210, 209, 210, 142, 242, 214, 215, 197,
	158794	+ /* 1030 */ 250, 22, 23, 276, 19, 26, 252, 101, 43, 44,
158633	158795	/* 1040 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
158634		- /* 1050 */ 55, 56, 57, 160, 19, 213, 214, 65, 43, 44,
	158796	+ /* 1050 */ 55, 56, 57, 160, 19, 211, 116, 192, 43, 44,
158635	158797	/* 1060 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
158636		- /* 1070 */ 55, 56, 57, 191, 116, 22, 191, 24, 43, 44,
	158798	+ /* 1070 */ 55, 56, 57, 192, 192, 22, 192, 266, 43, 44,
158637	158799	/* 1080 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
158638		- /* 1090 */ 55, 56, 57, 191, 261, 213, 214, 102, 103, 104,
158639		- /* 1100 */ 105, 106, 107, 108, 109, 110, 111, 112, 59, 19,
158640		- /* 1110 */ 191, 265, 59, 288, 191, 213, 214, 102, 103, 104,
158641		- /* 1120 */ 105, 106, 107, 108, 109, 110, 111, 112, 35, 191,
158642		- /* 1130 */ 66, 191, 213, 214, 191, 270, 46, 102, 103, 104,
158643		- /* 1140 */ 105, 106, 107, 108, 109, 110, 111, 112, 191, 85,
158644		- /* 1150 */ 265, 213, 214, 213, 214, 106, 107, 19, 94, 66,
158645		- /* 1160 */ 137, 138, 191, 114, 115, 116, 117, 74, 119, 116,
158646		- /* 1170 */ 213, 214, 202, 308, 309, 306, 127, 191, 235, 310,
158647		- /* 1180 */ 59, 191, 44, 45, 46, 47, 48, 49, 50, 51,
158648		- /* 1190 */ 52, 53, 54, 55, 56, 57, 191, 76, 196, 213,
158649		- /* 1200 */ 214, 152, 12, 154, 114, 191, 236, 237, 87, 145,
158650		- /* 1210 */ 89, 19, 20, 92, 22, 22, 23, 27, 191, 249,
158651		- /* 1220 */ 130, 202, 129, 202, 191, 235, 306, 152, 36, 154,
158652		- /* 1230 */ 310, 191, 42, 191, 191, 191, 115, 116, 117, 191,
	158800	+ /* 1090 */ 55, 56, 57, 192, 282, 192, 282, 102, 103, 104,
	158801	+ /* 1100 */ 105, 106, 107, 108, 109, 110, 111, 112, 59, 192,
	158802	+ /* 1110 */ 101, 279, 192, 192, 230, 283, 192, 102, 103, 104,
	158803	+ /* 1120 */ 105, 106, 107, 108, 109, 110, 111, 112, 204, 211,
	158804	+ /* 1130 */ 66, 214, 215, 289, 214, 215, 108, 102, 103, 104,
	158805	+ /* 1140 */ 105, 106, 107, 108, 109, 110, 111, 112, 266, 85,
	158806	+ /* 1150 */ 226, 192, 228, 22, 23, 106, 107, 19, 94, 106,
	158807	+ /* 1160 */ 107, 192, 134, 114, 115, 116, 117, 139, 119, 266,
	158808	+ /* 1170 */ 203, 206, 207, 214, 215, 192, 127, 192, 206, 207,
	158809	+ /* 1180 */ 59, 192, 44, 45, 46, 47, 48, 49, 50, 51,
	158810	+ /* 1190 */ 52, 53, 54, 55, 56, 57, 192, 76, 192, 214,
	158811	+ /* 1200 */ 215, 152, 284, 154, 237, 238, 192, 289, 87, 145,
	158812	+ /* 1210 */ 89, 19, 20, 92, 22, 22, 23, 250, 307, 236,
	158813	+ /* 1220 */ 214, 215, 311, 203, 12, 247, 192, 249, 36, 307,
	158814	+ /* 1230 */ 192, 262, 101, 311, 137, 138, 115, 116, 117, 27,
158653	158815	/* 1240 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
158654		- /* 1250 */ 112, 59, 99, 63, 191, 236, 237, 236, 237, 191,
158655		- /* 1260 */ 289, 213, 214, 71, 191, 144, 261, 191, 249, 191,
158656		- /* 1270 */ 249, 19, 20, 81, 22, 235, 213, 214, 235, 191,
158657		- /* 1280 */ 278, 213, 214, 191, 282, 132, 213, 214, 36, 213,
158658		- /* 1290 */ 214, 191, 100, 191, 101, 191, 191, 191, 106, 107,
158659		- /* 1300 */ 48, 213, 214, 261, 191, 113, 191, 115, 116, 117,
158660		- /* 1310 */ 191, 59, 120, 213, 214, 213, 214, 213, 214, 213,
158661		- /* 1320 */ 214, 22, 23, 71, 237, 59, 213, 214, 191, 137,
158662		- /* 1330 */ 138, 191, 213, 214, 191, 191, 249, 85, 191, 261,
158663		- /* 1340 */ 191, 26, 90, 15, 152, 153, 154, 155, 156, 19,
158664		- /* 1350 */ 213, 214, 100, 213, 214, 191, 213, 214, 106, 107,
158665		- /* 1360 */ 213, 214, 213, 214, 191, 113, 261, 115, 116, 117,
158666		- /* 1370 */ 253, 254, 120, 229, 191, 191, 191, 213, 214, 191,
158667		- /* 1380 */ 306, 289, 116, 26, 310, 191, 213, 214, 60, 19,
158668		- /* 1390 */ 296, 297, 24, 191, 46, 191, 213, 214, 213, 214,
158669		- /* 1400 */ 101, 213, 214, 191, 152, 153, 154, 155, 156, 0,
158670		- /* 1410 */ 1, 2, 191, 229, 5, 213, 214, 213, 214, 10,
158671		- /* 1420 */ 11, 12, 13, 14, 1, 2, 17, 191, 5, 19,
158672		- /* 1430 */ 20, 191, 22, 10, 11, 12, 13, 14, 191, 30,
158673		- /* 1440 */ 17, 32, 241, 148, 149, 115, 36, 191, 241, 40,
158674		- /* 1450 */ 191, 26, 251, 30, 191, 32, 141, 22, 251, 5,
158675		- /* 1460 */ 213, 214, 114, 40, 10, 11, 12, 13, 14, 59,
158676		- /* 1470 */ 134, 17, 213, 214, 191, 139, 213, 214, 191, 70,
158677		- /* 1480 */ 191, 71, 125, 191, 30, 115, 32, 78, 53, 191,
158678		- /* 1490 */ 81, 191, 191, 70, 40, 85, 213, 214, 191, 22,
158679		- /* 1500 */ 90, 78, 213, 214, 81, 213, 214, 98, 140, 120,
158680		- /* 1510 */ 100, 213, 214, 213, 214, 23, 106, 107, 26, 130,
158681		- /* 1520 */ 191, 98, 191, 113, 70, 115, 116, 117, 23, 22,
158682		- /* 1530 */ 120, 26, 78, 19, 191, 81, 19, 20, 61, 22,
158683		- /* 1540 */ 191, 132, 213, 214, 213, 214, 137, 138, 59, 191,
158684		- /* 1550 */ 191, 191, 98, 36, 128, 132, 213, 214, 128, 59,
158685		- /* 1560 */ 137, 138, 152, 153, 154, 155, 156, 83, 84, 144,
158686		- /* 1570 */ 161, 213, 214, 213, 214, 23, 59, 151, 26, 23,
158687		- /* 1580 */ 23, 151, 26, 26, 161, 59, 132, 23, 71, 191,
158688		- /* 1590 */ 26, 137, 138, 119, 120, 23, 19, 20, 26, 22,
158689		- /* 1600 */ 223, 23, 85, 23, 26, 116, 26, 90, 191, 7,
158690		- /* 1610 */ 8, 97, 152, 36, 154, 161, 116, 100, 23, 23,
158691		- /* 1620 */ 191, 26, 26, 106, 107, 191, 23, 223, 23, 26,
158692		- /* 1630 */ 113, 26, 115, 116, 117, 23, 59, 120, 26, 191,
158693		- /* 1640 */ 191, 191, 116, 255, 191, 252, 191, 140, 71, 191,
158694		- /* 1650 */ 315, 233, 191, 191, 191, 191, 191, 191, 191, 191,
158695		- /* 1660 */ 191, 285, 284, 239, 252, 252, 252, 252, 240, 152,
158696		- /* 1670 */ 153, 154, 155, 156, 189, 294, 268, 100, 242, 268,
158697		- /* 1680 */ 264, 211, 290, 106, 107, 108, 264, 256, 256, 243,
158698		- /* 1690 */ 113, 290, 115, 116, 117, 268, 217, 120, 226, 243,
158699		- /* 1700 */ 222, 268, 216, 19, 20, 246, 22, 216, 256, 216,
158700		- /* 1710 */ 194, 60, 38, 242, 277, 294, 240, 242, 198, 246,
158701		- /* 1720 */ 36, 140, 198, 198, 19, 20, 150, 22, 149, 152,
158702		- /* 1730 */ 153, 154, 155, 156, 294, 291, 291, 280, 22, 43,
158703		- /* 1740 */ 231, 36, 18, 59, 234, 234, 234, 234, 267, 269,
158704		- /* 1750 */ 18, 198, 197, 231, 148, 71, 269, 269, 243, 231,
158705		- /* 1760 */ 198, 243, 267, 197, 59, 157, 243, 198, 62, 287,
158706		- /* 1770 */ 243, 197, 22, 198, 114, 64, 71, 218, 218, 197,
158707		- /* 1780 */ 286, 198, 197, 215, 100, 215, 215, 224, 22, 125,
158708		- /* 1790 */ 106, 107, 164, 24, 221, 112, 143, 113, 302, 115,
158709		- /* 1800 */ 116, 117, 218, 215, 120, 100, 217, 221, 215, 215,
158710		- /* 1810 */ 309, 106, 107, 215, 224, 279, 279, 218, 113, 258,
158711		- /* 1820 */ 115, 116, 117, 114, 257, 120, 91, 198, 82, 147,
158712		- /* 1830 */ 144, 22, 274, 314, 198, 314, 152, 153, 154, 155,
158713		- /* 1840 */ 156, 276, 157, 146, 145, 258, 25, 247, 257, 201,
158714		- /* 1850 */ 258, 26, 200, 13, 257, 244, 246, 152, 153, 154,
158715		- /* 1860 */ 155, 156, 258, 262, 257, 247, 245, 243, 192, 192,
158716		- /* 1870 */ 6, 262, 204, 210, 219, 210, 210, 190, 190, 190,
158717		- /* 1880 */ 210, 219, 204, 211, 211, 210, 4, 3, 22, 162,
158718		- /* 1890 */ 15, 23, 16, 23, 204, 138, 129, 150, 26, 141,
158719		- /* 1900 */ 20, 24, 143, 16, 1, 141, 129, 129, 61, 53,
158720		- /* 1910 */ 37, 150, 297, 300, 300, 53, 53, 129, 53, 115,
158721		- /* 1920 */ 34, 140, 1, 5, 22, 114, 68, 26, 160, 68,
158722		- /* 1930 */ 75, 41, 140, 114, 24, 20, 19, 130, 124, 23,
158723		- /* 1940 */ 96, 22, 22, 37, 22, 67, 22, 59, 67, 24,
158724		- /* 1950 */ 22, 28, 67, 23, 148, 22, 97, 23, 23, 23,
158725		- /* 1960 */ 140, 23, 22, 26, 23, 23, 115, 22, 142, 26,
158726		- /* 1970 */ 75, 88, 75, 34, 23, 86, 44, 22, 34, 26,
158727		- /* 1980 */ 34, 34, 34, 34, 93, 24, 26, 23, 34, 23,
158728		- /* 1990 */ 23, 23, 23, 11, 23, 22, 26, 22, 22, 15,
158729		- /* 2000 */ 23, 23, 22, 22, 1, 26, 23, 140, 134, 140,
158730		- /* 2010 */ 1, 140, 316, 316, 316, 316, 316, 316, 316, 140,
158731		- /* 2020 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158732		- /* 2030 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158733		- /* 2040 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158734		- /* 2050 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158735		- /* 2060 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158736		- /* 2070 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158737		- /* 2080 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158738		- /* 2090 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158739		- /* 2100 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158740		- /* 2110 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158741		- /* 2120 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158742		- /* 2130 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158743		- /* 2140 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158744		- /* 2150 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158745		- /* 2160 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158746		- /* 2170 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158747		- /* 2180 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158748		- /* 2190 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158749		- /* 2200 */ 316, 316, 316,
	158816	+ /* 1250 */ 112, 59, 214, 215, 42, 203, 307, 237, 238, 192,
	158817	+ /* 1260 */ 311, 192, 26, 71, 192, 144, 262, 297, 298, 203,
	158818	+ /* 1270 */ 250, 19, 20, 81, 22, 63, 262, 254, 255, 15,
	158819	+ /* 1280 */ 26, 214, 215, 214, 215, 26, 214, 215, 36, 237,
	158820	+ /* 1290 */ 238, 192, 100, 114, 101, 192, 262, 192, 106, 107,
	158821	+ /* 1300 */ 48, 134, 250, 237, 238, 113, 139, 115, 116, 117,
	158822	+ /* 1310 */ 192, 59, 120, 214, 215, 242, 250, 214, 215, 214,
	158823	+ /* 1320 */ 215, 148, 149, 71, 60, 252, 242, 192, 149, 137,
	158824	+ /* 1330 */ 138, 192, 214, 215, 192, 19, 252, 85, 192, 59,
	158825	+ /* 1340 */ 192, 157, 90, 159, 152, 153, 154, 155, 156, 214,
	158826	+ /* 1350 */ 215, 192, 100, 214, 215, 19, 214, 215, 106, 107,
	158827	+ /* 1360 */ 214, 215, 214, 215, 22, 113, 192, 115, 116, 117,
	158828	+ /* 1370 */ 192, 242, 120, 214, 215, 192, 24, 192, 31, 192,
	158829	+ /* 1380 */ 144, 252, 26, 192, 125, 99, 39, 192, 214, 215,
	158830	+ /* 1390 */ 192, 59, 214, 215, 192, 141, 116, 214, 215, 214,
	158831	+ /* 1400 */ 215, 214, 215, 61, 152, 153, 154, 155, 156, 0,
	158832	+ /* 1410 */ 1, 2, 214, 215, 5, 192, 214, 215, 132, 10,
	158833	+ /* 1420 */ 11, 12, 13, 14, 1, 2, 17, 192, 5, 19,
	158834	+ /* 1430 */ 20, 115, 22, 10, 11, 12, 13, 14, 192, 30,
	158835	+ /* 1440 */ 17, 32, 23, 192, 23, 26, 36, 26, 116, 40,
	158836	+ /* 1450 */ 192, 115, 192, 30, 192, 32, 119, 120, 59, 5,
	158837	+ /* 1460 */ 214, 215, 128, 40, 10, 11, 12, 13, 14, 59,
	158838	+ /* 1470 */ 19, 17, 214, 215, 214, 215, 214, 215, 120, 70,
	158839	+ /* 1480 */ 192, 71, 22, 192, 30, 151, 32, 78, 130, 128,
	158840	+ /* 1490 */ 81, 192, 140, 70, 40, 85, 192, 141, 7, 8,
	158841	+ /* 1500 */ 90, 78, 214, 215, 81, 214, 215, 98, 83, 84,
	158842	+ /* 1510 */ 100, 192, 151, 214, 215, 116, 106, 107, 214, 215,
	158843	+ /* 1520 */ 192, 98, 192, 113, 70, 115, 116, 117, 23, 224,
	158844	+ /* 1530 */ 120, 26, 78, 214, 215, 81, 19, 20, 152, 22,
	158845	+ /* 1540 */ 154, 132, 214, 215, 214, 215, 137, 138, 97, 192,
	158846	+ /* 1550 */ 256, 192, 98, 36, 23, 132, 192, 26, 192, 192,
	158847	+ /* 1560 */ 137, 138, 152, 153, 154, 155, 156, 192, 192, 192,
	158848	+ /* 1570 */ 161, 214, 215, 214, 215, 192, 59, 192, 214, 215,
	158849	+ /* 1580 */ 214, 215, 192, 152, 161, 154, 132, 192, 71, 214,
	158850	+ /* 1590 */ 215, 137, 138, 192, 192, 192, 19, 20, 192, 22,
	158851	+ /* 1600 */ 140, 253, 85, 192, 214, 215, 192, 90, 23, 214,
	158852	+ /* 1610 */ 215, 26, 192, 36, 192, 161, 23, 100, 192, 26,
	158853	+ /* 1620 */ 214, 215, 192, 106, 107, 214, 215, 192, 23, 192,
	158854	+ /* 1630 */ 113, 26, 115, 116, 117, 23, 59, 120, 26, 23,
	158855	+ /* 1640 */ 23, 23, 26, 26, 26, 316, 234, 23, 71, 23,
	158856	+ /* 1650 */ 26, 192, 26, 192, 192, 192, 192, 192, 192, 192,
	158857	+ /* 1660 */ 192, 253, 212, 190, 286, 285, 253, 240, 253, 152,
	158858	+ /* 1670 */ 153, 154, 155, 156, 241, 243, 295, 100, 291, 291,
	158859	+ /* 1680 */ 223, 253, 227, 106, 107, 108, 269, 244, 244, 265,
	158860	+ /* 1690 */ 113, 257, 115, 116, 117, 257, 243, 120, 269, 218,
	158861	+ /* 1700 */ 217, 265, 217, 19, 20, 217, 22, 195, 269, 269,
	158862	+ /* 1710 */ 60, 295, 140, 257, 243, 241, 247, 247, 199, 278,
	158863	+ /* 1720 */ 36, 199, 199, 38, 19, 20, 150, 22, 149, 152,
	158864	+ /* 1730 */ 153, 154, 155, 156, 22, 43, 232, 295, 292, 292,
	158865	+ /* 1740 */ 18, 36, 235, 59, 268, 270, 235, 199, 235, 235,
	158866	+ /* 1750 */ 18, 198, 148, 281, 244, 71, 270, 270, 268, 244,
	158867	+ /* 1760 */ 232, 232, 244, 199, 59, 244, 198, 157, 288, 62,
	158868	+ /* 1770 */ 199, 287, 198, 22, 219, 219, 71, 199, 198, 114,
	158869	+ /* 1780 */ 199, 198, 216, 216, 100, 216, 225, 64, 22, 125,
	158870	+ /* 1790 */ 106, 107, 222, 164, 219, 222, 24, 113, 216, 115,
	158871	+ /* 1800 */ 116, 117, 218, 216, 120, 100, 216, 216, 310, 303,
	158872	+ /* 1810 */ 112, 106, 107, 225, 280, 280, 219, 143, 113, 259,
	158873	+ /* 1820 */ 115, 116, 117, 114, 259, 120, 199, 91, 82, 147,
	158874	+ /* 1830 */ 144, 315, 22, 275, 199, 315, 152, 153, 154, 155,
	158875	+ /* 1840 */ 156, 146, 145, 247, 258, 157, 25, 258, 245, 248,
	158876	+ /* 1850 */ 244, 259, 258, 202, 259, 248, 258, 152, 153, 154,
	158877	+ /* 1860 */ 155, 156, 263, 263, 26, 246, 13, 201, 193, 193,
	158878	+ /* 1870 */ 6, 191, 191, 205, 191, 220, 220, 205, 211, 277,
	158879	+ /* 1880 */ 211, 211, 211, 205, 4, 212, 3, 22, 162, 212,
	158880	+ /* 1890 */ 211, 15, 23, 16, 23, 138, 129, 150, 26, 24,
	158881	+ /* 1900 */ 141, 20, 16, 143, 1, 141, 129, 129, 61, 301,
	158882	+ /* 1910 */ 301, 298, 150, 53, 53, 37, 53, 129, 115, 53,
	158883	+ /* 1920 */ 140, 34, 1, 5, 22, 114, 68, 26, 160, 75,
	158884	+ /* 1930 */ 68, 41, 140, 114, 24, 20, 19, 130, 124, 23,
	158885	+ /* 1940 */ 67, 22, 22, 59, 22, 22, 67, 96, 24, 22,
	158886	+ /* 1950 */ 37, 23, 67, 28, 148, 22, 26, 23, 23, 23,
	158887	+ /* 1960 */ 23, 22, 140, 23, 97, 23, 34, 115, 22, 142,
	158888	+ /* 1970 */ 26, 75, 34, 44, 75, 34, 88, 34, 86, 34,
	158889	+ /* 1980 */ 23, 34, 93, 22, 24, 26, 34, 23, 26, 23,
	158890	+ /* 1990 */ 23, 23, 23, 11, 23, 22, 26, 22, 22, 140,
	158891	+ /* 2000 */ 23, 23, 22, 22, 134, 26, 23, 15, 140, 1,
	158892	+ /* 2010 */ 1, 317, 317, 317, 140, 317, 317, 317, 317, 317,
	158893	+ /* 2020 */ 317, 317, 140, 317, 317, 317, 317, 317, 317, 317,
	158894	+ /* 2030 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158895	+ /* 2040 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158896	+ /* 2050 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158897	+ /* 2060 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158898	+ /* 2070 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158899	+ /* 2080 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158900	+ /* 2090 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158901	+ /* 2100 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158902	+ /* 2110 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158903	+ /* 2120 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158904	+ /* 2130 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158905	+ /* 2140 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158906	+ /* 2150 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158907	+ /* 2160 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158908	+ /* 2170 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158909	+ /* 2180 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158910	+ /* 2190 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
	158911	+ /* 2200 */ 317, 317, 317, 317, 317, 317, 317,
158750	158912	};
158751	158913	#define YY_SHIFT_COUNT (569)
158752	158914	#define YY_SHIFT_MIN (0)
158753	158915	#define YY_SHIFT_MAX (2009)
158754	158916	static const unsigned short int yy_shift_ofst[] = {
158755		- /* 0 */ 1423, 1409, 1454, 1192, 1192, 36, 1252, 1410, 1517, 1684,
158756		- /* 10 */ 1684, 1684, 292, 0, 0, 180, 1015, 1684, 1684, 1684,
	158917	+ /* 0 */ 1423, 1409, 1454, 1192, 1192, 382, 1252, 1410, 1517, 1684,
	158918	+ /* 10 */ 1684, 1684, 221, 0, 0, 180, 1015, 1684, 1684, 1684,
158757	158919	/* 20 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158758		- /* 30 */ 1049, 1049, 1121, 1121, 54, 400, 36, 36, 36, 36,
158759		- /* 40 */ 36, 40, 110, 219, 289, 396, 439, 509, 548, 618,
	158920	+ /* 30 */ 1049, 1049, 1121, 1121, 54, 616, 382, 382, 382, 382,
	158921	+ /* 40 */ 382, 40, 110, 219, 289, 396, 439, 509, 548, 618,
158760	158922	/* 50 */ 657, 727, 766, 836, 995, 1015, 1015, 1015, 1015, 1015,
158761	158923	/* 60 */ 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015,
158762	158924	/* 70 */ 1015, 1015, 1015, 1035, 1015, 1138, 880, 880, 1577, 1684,
158763	158925	/* 80 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158764	158926	/* 90 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158765	158927	/* 100 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158766	158928	/* 110 */ 1684, 1684, 1684, 1705, 1684, 1684, 1684, 1684, 1684, 1684,
158767	158929	/* 120 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 146, 84, 84,
158768		- /* 130 */ 84, 84, 84, 362, 269, 125, 97, 453, 66, 66,
158769		- /* 140 */ 893, 1090, 66, 66, 533, 533, 66, 554, 554, 554,
158770		- /* 150 */ 554, 192, 587, 587, 695, 25, 2020, 2020, 290, 290,
158771		- /* 160 */ 290, 200, 514, 514, 514, 514, 939, 939, 442, 875,
158772		- /* 170 */ 935, 66, 66, 66, 66, 66, 66, 66, 66, 66,
	158930	+ /* 130 */ 84, 84, 84, 274, 315, 125, 97, 357, 66, 66,
	158931	+ /* 140 */ 893, 258, 66, 66, 371, 371, 66, 551, 551, 551,
	158932	+ /* 150 */ 551, 192, 209, 209, 278, 127, 2023, 2023, 621, 621,
	158933	+ /* 160 */ 621, 201, 398, 398, 398, 398, 939, 939, 442, 936,
	158934	+ /* 170 */ 1009, 66, 66, 66, 66, 66, 66, 66, 66, 66,
158773	158935	/* 180 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
158774		- /* 190 */ 66, 601, 601, 66, 729, 878, 878, 1266, 1266, 552,
158775		- /* 200 */ 1023, 2020, 2020, 2020, 2020, 2020, 2020, 2020, 307, 490,
158776		- /* 210 */ 490, 567, 393, 517, 467, 672, 242, 682, 675, 66,
158777		- /* 220 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 616,
	158936	+ /* 190 */ 66, 710, 710, 66, 776, 435, 435, 410, 410, 372,
	158937	+ /* 200 */ 1097, 2023, 2023, 2023, 2023, 2023, 2023, 2023, 250, 490,
	158938	+ /* 210 */ 490, 511, 451, 516, 252, 566, 575, 781, 673, 66,
	158939	+ /* 220 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 722,
158778	158940	/* 230 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
158779		- /* 240 */ 66, 66, 1093, 1093, 1093, 66, 66, 66, 778, 66,
158780		- /* 250 */ 66, 66, 1053, 1064, 66, 66, 1190, 66, 66, 66,
158781		- /* 260 */ 66, 66, 66, 66, 66, 722, 992, 718, 253, 253,
158782		- /* 270 */ 253, 253, 338, 718, 718, 888, 403, 852, 1328, 254,
158783		- /* 280 */ 1295, 721, 1330, 1295, 1330, 1370, 234, 254, 254, 234,
158784		- /* 290 */ 254, 721, 1370, 1357, 1492, 1348, 385, 385, 385, 1330,
158785		- /* 300 */ 1425, 1425, 643, 1315, 1336, 1004, 1651, 1651, 1581, 1581,
158786		- /* 310 */ 1674, 1674, 1581, 1576, 1579, 1716, 1696, 1724, 1724, 1724,
158787		- /* 320 */ 1724, 1581, 1732, 1606, 1579, 1579, 1606, 1716, 1696, 1606,
158788		- /* 330 */ 1696, 1606, 1581, 1732, 1608, 1706, 1581, 1732, 1750, 1581,
158789		- /* 340 */ 1732, 1581, 1732, 1750, 1660, 1660, 1660, 1711, 1766, 1766,
158790		- /* 350 */ 1750, 1660, 1664, 1660, 1711, 1660, 1660, 1628, 1769, 1683,
158791		- /* 360 */ 1683, 1750, 1653, 1709, 1653, 1709, 1653, 1709, 1653, 1709,
158792		- /* 370 */ 1581, 1735, 1735, 1746, 1746, 1682, 1686, 1809, 1581, 1685,
158793		- /* 380 */ 1682, 1697, 1699, 1606, 1821, 1825, 1840, 1840, 1864, 1864,
158794		- /* 390 */ 1864, 2020, 2020, 2020, 2020, 2020, 2020, 2020, 2020, 2020,
158795		- /* 400 */ 2020, 2020, 2020, 2020, 2020, 2020, 599, 223, 1193, 1299,
158796		- /* 410 */ 228, 780, 958, 1505, 1153, 1435, 1368, 1426, 1430, 1552,
158797		- /* 420 */ 1477, 1556, 1557, 1564, 1572, 1578, 1580, 1489, 1474, 1602,
158798		- /* 430 */ 1389, 1514, 1500, 1595, 1596, 1484, 1603, 1075, 1460, 1605,
158799		- /* 440 */ 1612, 1526, 1507, 1882, 1884, 1866, 1727, 1875, 1876, 1868,
158800		- /* 450 */ 1870, 1757, 1747, 1767, 1872, 1872, 1877, 1758, 1880, 1759,
158801		- /* 460 */ 1887, 1903, 1764, 1777, 1872, 1778, 1847, 1873, 1872, 1761,
158802		- /* 470 */ 1856, 1862, 1863, 1865, 1788, 1804, 1886, 1781, 1921, 1918,
158803		- /* 480 */ 1902, 1811, 1768, 1858, 1901, 1861, 1855, 1890, 1792, 1819,
158804		- /* 490 */ 1910, 1915, 1917, 1807, 1814, 1919, 1878, 1920, 1922, 1916,
158805		- /* 500 */ 1924, 1881, 1888, 1925, 1844, 1923, 1928, 1885, 1906, 1930,
158806		- /* 510 */ 1806, 1933, 1934, 1935, 1936, 1937, 1938, 1940, 1859, 1820,
158807		- /* 520 */ 1941, 1942, 1851, 1939, 1945, 1826, 1943, 1944, 1946, 1947,
158808		- /* 530 */ 1948, 1883, 1895, 1889, 1932, 1897, 1891, 1949, 1951, 1955,
158809		- /* 540 */ 1961, 1953, 1960, 1954, 1964, 1943, 1966, 1967, 1968, 1969,
	158941	+ /* 240 */ 66, 66, 790, 790, 790, 66, 66, 66, 883, 66,
	158942	+ /* 250 */ 66, 66, 891, 1064, 66, 66, 1212, 66, 66, 66,
	158943	+ /* 260 */ 66, 66, 66, 66, 66, 725, 763, 177, 940, 940,
	158944	+ /* 270 */ 940, 940, 337, 177, 177, 1028, 1053, 670, 1264, 1179,
	158945	+ /* 280 */ 1173, 1254, 1316, 1173, 1316, 1336, 50, 1179, 1179, 50,
	158946	+ /* 290 */ 1179, 1254, 1336, 1259, 732, 532, 1347, 1347, 1347, 1316,
	158947	+ /* 300 */ 1236, 1236, 1184, 1356, 1167, 898, 1650, 1650, 1572, 1572,
	158948	+ /* 310 */ 1685, 1685, 1572, 1576, 1579, 1712, 1692, 1722, 1722, 1722,
	158949	+ /* 320 */ 1722, 1572, 1732, 1604, 1579, 1579, 1604, 1712, 1692, 1604,
	158950	+ /* 330 */ 1692, 1604, 1572, 1732, 1610, 1707, 1572, 1732, 1751, 1572,
	158951	+ /* 340 */ 1732, 1572, 1732, 1751, 1665, 1665, 1665, 1723, 1766, 1766,
	158952	+ /* 350 */ 1751, 1665, 1664, 1665, 1723, 1665, 1665, 1629, 1772, 1698,
	158953	+ /* 360 */ 1698, 1751, 1674, 1709, 1674, 1709, 1674, 1709, 1674, 1709,
	158954	+ /* 370 */ 1572, 1736, 1736, 1746, 1746, 1682, 1686, 1810, 1572, 1688,
	158955	+ /* 380 */ 1682, 1695, 1697, 1604, 1821, 1838, 1853, 1853, 1864, 1864,
	158956	+ /* 390 */ 1864, 2023, 2023, 2023, 2023, 2023, 2023, 2023, 2023, 2023,
	158957	+ /* 400 */ 2023, 2023, 2023, 2023, 2023, 2023, 232, 101, 1131, 1193,
	158958	+ /* 410 */ 619, 679, 841, 1421, 1286, 115, 1352, 1334, 1361, 1419,
	158959	+ /* 420 */ 1342, 1505, 1531, 1585, 1593, 1605, 1612, 1280, 1337, 1491,
	158960	+ /* 430 */ 1358, 1451, 1332, 1616, 1617, 1425, 1618, 1386, 1431, 1624,
	158961	+ /* 440 */ 1626, 1399, 1460, 1880, 1883, 1865, 1726, 1876, 1877, 1869,
	158962	+ /* 450 */ 1871, 1757, 1747, 1767, 1872, 1872, 1875, 1759, 1881, 1760,
	158963	+ /* 460 */ 1886, 1903, 1764, 1777, 1872, 1778, 1847, 1878, 1872, 1762,
	158964	+ /* 470 */ 1860, 1861, 1863, 1866, 1788, 1803, 1887, 1780, 1921, 1918,
	158965	+ /* 480 */ 1902, 1811, 1768, 1858, 1901, 1862, 1854, 1890, 1792, 1819,
	158966	+ /* 490 */ 1910, 1915, 1917, 1807, 1814, 1919, 1873, 1920, 1922, 1916,
	158967	+ /* 500 */ 1923, 1879, 1884, 1924, 1851, 1925, 1927, 1885, 1913, 1928,
	158968	+ /* 510 */ 1806, 1933, 1934, 1935, 1936, 1930, 1937, 1939, 1867, 1822,
	158969	+ /* 520 */ 1940, 1942, 1852, 1932, 1946, 1827, 1944, 1938, 1941, 1943,
	158970	+ /* 530 */ 1945, 1888, 1896, 1892, 1929, 1899, 1889, 1947, 1957, 1961,
	158971	+ /* 540 */ 1960, 1959, 1962, 1952, 1964, 1944, 1966, 1967, 1968, 1969,
158810	158972	/* 550 */ 1970, 1971, 1973, 1982, 1975, 1976, 1977, 1978, 1980, 1981,
158811		- /* 560 */ 1979, 1874, 1867, 1869, 1871, 1879, 1983, 1984, 2003, 2009,
	158973	+ /* 560 */ 1979, 1870, 1859, 1868, 1874, 1882, 1983, 1992, 2008, 2009,
158812	158974	};
158813	158975	#define YY_REDUCE_COUNT (405)
158814		-#define YY_REDUCE_MIN (-265)
158815		-#define YY_REDUCE_MAX (1690)
	158976	+#define YY_REDUCE_MIN (-266)
	158977	+#define YY_REDUCE_MAX (1683)
158816	158978	static const short yy_reduce_ofst[] = {
158817		- /* 0 */ 111, 168, 386, 761, -176, -174, -191, -189, -181, -178,
158818		- /* 10 */ 176, 263, 44, -207, -204, -265, -139, -114, 158, 504,
158819		- /* 20 */ 525, 544, 612, 614, 650, 652, 765, 265, 703, 705,
158820		- /* 30 */ 70, 714, -187, 127, 774, 713, 767, 769, 970, 1019,
158821		- /* 40 */ 1021, -255, -255, -255, -255, -255, -255, -255, -255, -255,
158822		- /* 50 */ -255, -255, -255, -255, -255, -255, -255, -255, -255, -255,
158823		- /* 60 */ -255, -255, -255, -255, -255, -255, -255, -255, -255, -255,
158824		- /* 70 */ -255, -255, -255, -255, -255, -255, -255, -255, 394, 542,
158825		- /* 80 */ 816, 818, 842, 882, 902, 919, 938, 940, 957, 986,
158826		- /* 90 */ 1048, 1063, 1068, 1073, 1076, 1088, 1100, 1102, 1104, 1106,
158827		- /* 100 */ 1113, 1119, 1137, 1140, 1143, 1147, 1149, 1164, 1173, 1183,
158828		- /* 110 */ 1185, 1188, 1202, 1204, 1247, 1259, 1263, 1283, 1289, 1292,
158829		- /* 120 */ 1298, 1300, 1329, 1331, 1343, 1358, 1360, -255, -255, -255,
158830		- /* 130 */ -255, -255, -255, -255, -255, 196, -255, 387, -177, 507,
158831		- /* 140 */ 1002, -219, 557, -93, -167, 638, -121, 284, 500, 284,
158832		- /* 150 */ 500, 247, 651, 865, -255, -255, -255, -255, -85, -85,
158833		- /* 160 */ -85, 237, 171, 602, 846, 885, -212, -203, 217, 380,
158834		- /* 170 */ 380, -23, 161, 653, 712, 773, 943, 990, 1040, 563,
158835		- /* 180 */ 833, 971, 1005, 1042, 1092, 1078, 1043, 1144, 1184, -186,
158836		- /* 190 */ 1105, 318, 869, 7, 825, 920, 1074, 704, 706, 390,
158837		- /* 200 */ 1087, 1094, 336, 545, 772, 1201, 1117, 1207, -179, -137,
158838		- /* 210 */ -112, -13, 18, 112, 197, 418, 495, 508, 777, 809,
158839		- /* 220 */ 923, 1014, 1027, 1033, 1044, 1115, 1194, 1212, 1221, 209,
158840		- /* 230 */ 1236, 1240, 1256, 1287, 1301, 1307, 1349, 1359, 1398, 1417,
158841		- /* 240 */ 1429, 1434, 681, 1377, 1404, 1448, 1449, 1450, 1388, 1453,
158842		- /* 250 */ 1455, 1458, 1393, 1335, 1461, 1462, 1418, 1463, 197, 1464,
158843		- /* 260 */ 1465, 1466, 1467, 1468, 1469, 1376, 1378, 1424, 1412, 1413,
158844		- /* 270 */ 1414, 1415, 1388, 1424, 1424, 1428, 1470, 1485, 1381, 1408,
158845		- /* 280 */ 1416, 1436, 1431, 1422, 1432, 1392, 1446, 1411, 1427, 1456,
158846		- /* 290 */ 1433, 1471, 1401, 1479, 1472, 1478, 1486, 1491, 1493, 1452,
158847		- /* 300 */ 1459, 1473, 1437, 1475, 1476, 1516, 1421, 1440, 1520, 1524,
158848		- /* 310 */ 1444, 1445, 1525, 1457, 1480, 1481, 1509, 1510, 1511, 1512,
158849		- /* 320 */ 1513, 1553, 1555, 1515, 1487, 1488, 1518, 1495, 1522, 1523,
158850		- /* 330 */ 1528, 1527, 1562, 1566, 1482, 1494, 1569, 1574, 1559, 1575,
158851		- /* 340 */ 1582, 1583, 1585, 1560, 1568, 1570, 1571, 1563, 1573, 1586,
158852		- /* 350 */ 1584, 1588, 1589, 1593, 1590, 1594, 1598, 1501, 1496, 1536,
158853		- /* 360 */ 1537, 1599, 1561, 1567, 1587, 1591, 1592, 1597, 1604, 1607,
158854		- /* 370 */ 1629, 1519, 1521, 1601, 1609, 1600, 1610, 1558, 1636, 1565,
158855		- /* 380 */ 1618, 1621, 1611, 1624, 1648, 1652, 1676, 1677, 1687, 1688,
158856		- /* 390 */ 1689, 1613, 1614, 1615, 1668, 1663, 1665, 1666, 1670, 1678,
158857		- /* 400 */ 1655, 1662, 1672, 1673, 1675, 1690,
	158979	+ /* 0 */ 111, 168, 272, 760, -177, -175, -192, -190, -182, -179,
	158980	+ /* 10 */ 216, 220, 481, -208, -205, -266, -140, -115, 241, 393,
	158981	+ /* 20 */ 523, 325, 612, 632, 542, 651, 764, 757, 702, 762,
	158982	+ /* 30 */ 812, 814, -188, 273, 924, 386, 758, 967, 1020, 1052,
	158983	+ /* 40 */ 1066, -256, -256, -256, -256, -256, -256, -256, -256, -256,
	158984	+ /* 50 */ -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
	158985	+ /* 60 */ -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
	158986	+ /* 70 */ -256, -256, -256, -256, -256, -256, -256, -256, 195, 222,
	158987	+ /* 80 */ 813, 917, 920, 959, 985, 1006, 1038, 1067, 1069, 1072,
	158988	+ /* 90 */ 1099, 1103, 1105, 1118, 1135, 1139, 1142, 1146, 1148, 1159,
	158989	+ /* 100 */ 1174, 1178, 1183, 1185, 1187, 1198, 1202, 1246, 1258, 1260,
	158990	+ /* 110 */ 1262, 1288, 1291, 1299, 1304, 1319, 1328, 1330, 1357, 1359,
	158991	+ /* 120 */ 1364, 1366, 1375, 1390, 1395, 1406, 1411, -256, -256, -256,
	158992	+ /* 130 */ -256, -256, -256, -256, -256, 447, -256, 555, -178, 605,
	158993	+ /* 140 */ 832, -220, 606, -94, -168, 36, -122, 730, 780, 730,
	158994	+ /* 150 */ 780, 918, -136, 338, -256, -256, -256, -256, 80, 80,
	158995	+ /* 160 */ 80, 720, 703, 811, 882, 903, -213, -204, 106, 330,
	158996	+ /* 170 */ 330, -77, 236, 320, 599, 67, 457, 675, 729, 395,
	158997	+ /* 180 */ 268, 611, 969, 1004, 726, 1014, 983, 123, 884, 608,
	158998	+ /* 190 */ 1034, 547, 911, 650, 844, 922, 949, 965, 972, 978,
	158999	+ /* 200 */ 449, 970, 718, 784, 1073, 1084, 1023, 1129, -209, -180,
	159000	+ /* 210 */ -113, 114, 183, 329, 345, 391, 446, 502, 609, 667,
	159001	+ /* 220 */ 713, 817, 865, 881, 901, 921, 989, 1191, 1195, 214,
	159002	+ /* 230 */ 1223, 1235, 1251, 1367, 1376, 1377, 1383, 1385, 1401, 1402,
	159003	+ /* 240 */ 1403, 1414, 584, 638, 1305, 1420, 1422, 1426, 1294, 1430,
	159004	+ /* 250 */ 1435, 1437, 1348, 1329, 1459, 1461, 1412, 1462, 345, 1463,
	159005	+ /* 260 */ 1464, 1465, 1466, 1467, 1468, 1378, 1380, 1427, 1408, 1413,
	159006	+ /* 270 */ 1415, 1428, 1294, 1427, 1427, 1433, 1450, 1473, 1381, 1417,
	159007	+ /* 280 */ 1424, 1432, 1434, 1436, 1438, 1387, 1443, 1429, 1439, 1444,
	159008	+ /* 290 */ 1440, 1453, 1388, 1481, 1455, 1457, 1483, 1485, 1488, 1456,
	159009	+ /* 300 */ 1469, 1470, 1441, 1471, 1474, 1512, 1416, 1442, 1519, 1522,
	159010	+ /* 310 */ 1446, 1447, 1523, 1472, 1475, 1476, 1504, 1507, 1511, 1513,
	159011	+ /* 320 */ 1514, 1548, 1553, 1510, 1486, 1487, 1515, 1490, 1528, 1518,
	159012	+ /* 330 */ 1529, 1521, 1564, 1568, 1480, 1484, 1571, 1574, 1555, 1578,
	159013	+ /* 340 */ 1580, 1581, 1583, 1556, 1566, 1567, 1569, 1561, 1570, 1573,
	159014	+ /* 350 */ 1575, 1582, 1584, 1587, 1588, 1590, 1591, 1498, 1506, 1534,
	159015	+ /* 360 */ 1535, 1597, 1560, 1586, 1565, 1589, 1592, 1594, 1595, 1598,
	159016	+ /* 370 */ 1627, 1516, 1520, 1599, 1600, 1601, 1596, 1558, 1635, 1602,
	159017	+ /* 380 */ 1607, 1619, 1603, 1606, 1651, 1666, 1675, 1676, 1680, 1681,
	159018	+ /* 390 */ 1683, 1608, 1609, 1613, 1668, 1667, 1669, 1670, 1671, 1672,
	159019	+ /* 400 */ 1655, 1656, 1673, 1677, 1679, 1678,
158858	159020	};
158859	159021	static const YYACTIONTYPE yy_default[] = {
158860	159022	/* 0 */ 1623, 1623, 1623, 1453, 1223, 1332, 1223, 1223, 1223, 1453,
158861	159023	/* 10 */ 1453, 1453, 1223, 1362, 1362, 1506, 1254, 1223, 1223, 1223,
158862	159024	/* 20 */ 1223, 1223, 1223, 1223, 1223, 1223, 1223, 1452, 1223, 1223,
		@@ -159112,10 +159274,11 @@
159112	159274	0, /* VECTOR => nothing */
159113	159275	0, /* SELECT_COLUMN => nothing */
159114	159276	0, /* IF_NULL_ROW => nothing */
159115	159277	0, /* ASTERISK => nothing */
159116	159278	0, /* SPAN => nothing */
	159279	+ 0, /* ERROR => nothing */
159117	159280	0, /* SPACE => nothing */
159118	159281	0, /* ILLEGAL => nothing */
159119	159282	};
159120	159283	#endif /* YYFALLBACK */
159121	159284
		@@ -159383,145 +159546,146 @@
159383	159546	/* 176 */ "VECTOR",
159384	159547	/* 177 */ "SELECT_COLUMN",
159385	159548	/* 178 */ "IF_NULL_ROW",
159386	159549	/* 179 */ "ASTERISK",
159387	159550	/* 180 */ "SPAN",
159388		- /* 181 */ "SPACE",
159389		- /* 182 */ "ILLEGAL",
159390		- /* 183 */ "input",
159391		- /* 184 */ "cmdlist",
159392		- /* 185 */ "ecmd",
159393		- /* 186 */ "cmdx",
159394		- /* 187 */ "explain",
159395		- /* 188 */ "cmd",
159396		- /* 189 */ "transtype",
159397		- /* 190 */ "trans_opt",
159398		- /* 191 */ "nm",
159399		- /* 192 */ "savepoint_opt",
159400		- /* 193 */ "create_table",
159401		- /* 194 */ "create_table_args",
159402		- /* 195 */ "createkw",
159403		- /* 196 */ "temp",
159404		- /* 197 */ "ifnotexists",
159405		- /* 198 */ "dbnm",
159406		- /* 199 */ "columnlist",
159407		- /* 200 */ "conslist_opt",
159408		- /* 201 */ "table_options",
159409		- /* 202 */ "select",
159410		- /* 203 */ "columnname",
159411		- /* 204 */ "carglist",
159412		- /* 205 */ "typetoken",
159413		- /* 206 */ "typename",
159414		- /* 207 */ "signed",
159415		- /* 208 */ "plus_num",
159416		- /* 209 */ "minus_num",
159417		- /* 210 */ "scanpt",
159418		- /* 211 */ "scantok",
159419		- /* 212 */ "ccons",
159420		- /* 213 */ "term",
159421		- /* 214 */ "expr",
159422		- /* 215 */ "onconf",
159423		- /* 216 */ "sortorder",
159424		- /* 217 */ "autoinc",
159425		- /* 218 */ "eidlist_opt",
159426		- /* 219 */ "refargs",
159427		- /* 220 */ "defer_subclause",
159428		- /* 221 */ "generated",
159429		- /* 222 */ "refarg",
159430		- /* 223 */ "refact",
159431		- /* 224 */ "init_deferred_pred_opt",
159432		- /* 225 */ "conslist",
159433		- /* 226 */ "tconscomma",
159434		- /* 227 */ "tcons",
159435		- /* 228 */ "sortlist",
159436		- /* 229 */ "eidlist",
159437		- /* 230 */ "defer_subclause_opt",
159438		- /* 231 */ "orconf",
159439		- /* 232 */ "resolvetype",
159440		- /* 233 */ "raisetype",
159441		- /* 234 */ "ifexists",
159442		- /* 235 */ "fullname",
159443		- /* 236 */ "selectnowith",
159444		- /* 237 */ "oneselect",
159445		- /* 238 */ "wqlist",
159446		- /* 239 */ "multiselect_op",
159447		- /* 240 */ "distinct",
159448		- /* 241 */ "selcollist",
159449		- /* 242 */ "from",
159450		- /* 243 */ "where_opt",
159451		- /* 244 */ "groupby_opt",
159452		- /* 245 */ "having_opt",
159453		- /* 246 */ "orderby_opt",
159454		- /* 247 */ "limit_opt",
159455		- /* 248 */ "window_clause",
159456		- /* 249 */ "values",
159457		- /* 250 */ "nexprlist",
159458		- /* 251 */ "sclp",
159459		- /* 252 */ "as",
159460		- /* 253 */ "seltablist",
159461		- /* 254 */ "stl_prefix",
159462		- /* 255 */ "joinop",
159463		- /* 256 */ "indexed_opt",
159464		- /* 257 */ "on_opt",
159465		- /* 258 */ "using_opt",
159466		- /* 259 */ "exprlist",
159467		- /* 260 */ "xfullname",
159468		- /* 261 */ "idlist",
159469		- /* 262 */ "nulls",
159470		- /* 263 */ "with",
159471		- /* 264 */ "where_opt_ret",
159472		- /* 265 */ "setlist",
159473		- /* 266 */ "insert_cmd",
159474		- /* 267 */ "idlist_opt",
159475		- /* 268 */ "upsert",
159476		- /* 269 */ "returning",
159477		- /* 270 */ "filter_over",
159478		- /* 271 */ "likeop",
159479		- /* 272 */ "between_op",
159480		- /* 273 */ "in_op",
159481		- /* 274 */ "paren_exprlist",
159482		- /* 275 */ "case_operand",
159483		- /* 276 */ "case_exprlist",
159484		- /* 277 */ "case_else",
159485		- /* 278 */ "uniqueflag",
159486		- /* 279 */ "collate",
159487		- /* 280 */ "vinto",
159488		- /* 281 */ "nmnum",
159489		- /* 282 */ "trigger_decl",
159490		- /* 283 */ "trigger_cmd_list",
159491		- /* 284 */ "trigger_time",
159492		- /* 285 */ "trigger_event",
159493		- /* 286 */ "foreach_clause",
159494		- /* 287 */ "when_clause",
159495		- /* 288 */ "trigger_cmd",
159496		- /* 289 */ "trnm",
159497		- /* 290 */ "tridxby",
159498		- /* 291 */ "database_kw_opt",
159499		- /* 292 */ "key_opt",
159500		- /* 293 */ "add_column_fullname",
159501		- /* 294 */ "kwcolumn_opt",
159502		- /* 295 */ "create_vtab",
159503		- /* 296 */ "vtabarglist",
159504		- /* 297 */ "vtabarg",
159505		- /* 298 */ "vtabargtoken",
159506		- /* 299 */ "lp",
159507		- /* 300 */ "anylist",
159508		- /* 301 */ "wqitem",
159509		- /* 302 */ "wqas",
159510		- /* 303 */ "windowdefn_list",
159511		- /* 304 */ "windowdefn",
159512		- /* 305 */ "window",
159513		- /* 306 */ "frame_opt",
159514		- /* 307 */ "part_opt",
159515		- /* 308 */ "filter_clause",
159516		- /* 309 */ "over_clause",
159517		- /* 310 */ "range_or_rows",
159518		- /* 311 */ "frame_bound",
159519		- /* 312 */ "frame_bound_s",
159520		- /* 313 */ "frame_bound_e",
159521		- /* 314 */ "frame_exclude_opt",
159522		- /* 315 */ "frame_exclude",
	159551	+ /* 181 */ "ERROR",
	159552	+ /* 182 */ "SPACE",
	159553	+ /* 183 */ "ILLEGAL",
	159554	+ /* 184 */ "input",
	159555	+ /* 185 */ "cmdlist",
	159556	+ /* 186 */ "ecmd",
	159557	+ /* 187 */ "cmdx",
	159558	+ /* 188 */ "explain",
	159559	+ /* 189 */ "cmd",
	159560	+ /* 190 */ "transtype",
	159561	+ /* 191 */ "trans_opt",
	159562	+ /* 192 */ "nm",
	159563	+ /* 193 */ "savepoint_opt",
	159564	+ /* 194 */ "create_table",
	159565	+ /* 195 */ "create_table_args",
	159566	+ /* 196 */ "createkw",
	159567	+ /* 197 */ "temp",
	159568	+ /* 198 */ "ifnotexists",
	159569	+ /* 199 */ "dbnm",
	159570	+ /* 200 */ "columnlist",
	159571	+ /* 201 */ "conslist_opt",
	159572	+ /* 202 */ "table_options",
	159573	+ /* 203 */ "select",
	159574	+ /* 204 */ "columnname",
	159575	+ /* 205 */ "carglist",
	159576	+ /* 206 */ "typetoken",
	159577	+ /* 207 */ "typename",
	159578	+ /* 208 */ "signed",
	159579	+ /* 209 */ "plus_num",
	159580	+ /* 210 */ "minus_num",
	159581	+ /* 211 */ "scanpt",
	159582	+ /* 212 */ "scantok",
	159583	+ /* 213 */ "ccons",
	159584	+ /* 214 */ "term",
	159585	+ /* 215 */ "expr",
	159586	+ /* 216 */ "onconf",
	159587	+ /* 217 */ "sortorder",
	159588	+ /* 218 */ "autoinc",
	159589	+ /* 219 */ "eidlist_opt",
	159590	+ /* 220 */ "refargs",
	159591	+ /* 221 */ "defer_subclause",
	159592	+ /* 222 */ "generated",
	159593	+ /* 223 */ "refarg",
	159594	+ /* 224 */ "refact",
	159595	+ /* 225 */ "init_deferred_pred_opt",
	159596	+ /* 226 */ "conslist",
	159597	+ /* 227 */ "tconscomma",
	159598	+ /* 228 */ "tcons",
	159599	+ /* 229 */ "sortlist",
	159600	+ /* 230 */ "eidlist",
	159601	+ /* 231 */ "defer_subclause_opt",
	159602	+ /* 232 */ "orconf",
	159603	+ /* 233 */ "resolvetype",
	159604	+ /* 234 */ "raisetype",
	159605	+ /* 235 */ "ifexists",
	159606	+ /* 236 */ "fullname",
	159607	+ /* 237 */ "selectnowith",
	159608	+ /* 238 */ "oneselect",
	159609	+ /* 239 */ "wqlist",
	159610	+ /* 240 */ "multiselect_op",
	159611	+ /* 241 */ "distinct",
	159612	+ /* 242 */ "selcollist",
	159613	+ /* 243 */ "from",
	159614	+ /* 244 */ "where_opt",
	159615	+ /* 245 */ "groupby_opt",
	159616	+ /* 246 */ "having_opt",
	159617	+ /* 247 */ "orderby_opt",
	159618	+ /* 248 */ "limit_opt",
	159619	+ /* 249 */ "window_clause",
	159620	+ /* 250 */ "values",
	159621	+ /* 251 */ "nexprlist",
	159622	+ /* 252 */ "sclp",
	159623	+ /* 253 */ "as",
	159624	+ /* 254 */ "seltablist",
	159625	+ /* 255 */ "stl_prefix",
	159626	+ /* 256 */ "joinop",
	159627	+ /* 257 */ "indexed_opt",
	159628	+ /* 258 */ "on_opt",
	159629	+ /* 259 */ "using_opt",
	159630	+ /* 260 */ "exprlist",
	159631	+ /* 261 */ "xfullname",
	159632	+ /* 262 */ "idlist",
	159633	+ /* 263 */ "nulls",
	159634	+ /* 264 */ "with",
	159635	+ /* 265 */ "where_opt_ret",
	159636	+ /* 266 */ "setlist",
	159637	+ /* 267 */ "insert_cmd",
	159638	+ /* 268 */ "idlist_opt",
	159639	+ /* 269 */ "upsert",
	159640	+ /* 270 */ "returning",
	159641	+ /* 271 */ "filter_over",
	159642	+ /* 272 */ "likeop",
	159643	+ /* 273 */ "between_op",
	159644	+ /* 274 */ "in_op",
	159645	+ /* 275 */ "paren_exprlist",
	159646	+ /* 276 */ "case_operand",
	159647	+ /* 277 */ "case_exprlist",
	159648	+ /* 278 */ "case_else",
	159649	+ /* 279 */ "uniqueflag",
	159650	+ /* 280 */ "collate",
	159651	+ /* 281 */ "vinto",
	159652	+ /* 282 */ "nmnum",
	159653	+ /* 283 */ "trigger_decl",
	159654	+ /* 284 */ "trigger_cmd_list",
	159655	+ /* 285 */ "trigger_time",
	159656	+ /* 286 */ "trigger_event",
	159657	+ /* 287 */ "foreach_clause",
	159658	+ /* 288 */ "when_clause",
	159659	+ /* 289 */ "trigger_cmd",
	159660	+ /* 290 */ "trnm",
	159661	+ /* 291 */ "tridxby",
	159662	+ /* 292 */ "database_kw_opt",
	159663	+ /* 293 */ "key_opt",
	159664	+ /* 294 */ "add_column_fullname",
	159665	+ /* 295 */ "kwcolumn_opt",
	159666	+ /* 296 */ "create_vtab",
	159667	+ /* 297 */ "vtabarglist",
	159668	+ /* 298 */ "vtabarg",
	159669	+ /* 299 */ "vtabargtoken",
	159670	+ /* 300 */ "lp",
	159671	+ /* 301 */ "anylist",
	159672	+ /* 302 */ "wqitem",
	159673	+ /* 303 */ "wqas",
	159674	+ /* 304 */ "windowdefn_list",
	159675	+ /* 305 */ "windowdefn",
	159676	+ /* 306 */ "window",
	159677	+ /* 307 */ "frame_opt",
	159678	+ /* 308 */ "part_opt",
	159679	+ /* 309 */ "filter_clause",
	159680	+ /* 310 */ "over_clause",
	159681	+ /* 311 */ "range_or_rows",
	159682	+ /* 312 */ "frame_bound",
	159683	+ /* 313 */ "frame_bound_s",
	159684	+ /* 314 */ "frame_bound_e",
	159685	+ /* 315 */ "frame_exclude_opt",
	159686	+ /* 316 */ "frame_exclude",
159523	159687	};
159524	159688	#endif /* defined(YYCOVERAGE) \|\| !defined(NDEBUG) */
159525	159689
159526	159690	#ifndef NDEBUG
159527	159691	/* For tracing reduce actions, the names of all rules are required.
		@@ -160048,103 +160212,103 @@
160048	160212	** Note: during a reduce, the only symbols destroyed are those
160049	160213	** which appear on the RHS of the rule, but which are not used
160050	160214	** inside the C code.
160051	160215	*/
160052	160216	/******* Begin destructor definitions *************************************/
160053		- case 202: /* select */
160054		- case 236: /* selectnowith */
160055		- case 237: /* oneselect */
160056		- case 249: /* values */
160057		-{
160058		-sqlite3SelectDelete(pParse->db, (yypminor->yy307));
160059		-}
160060		- break;
160061		- case 213: /* term */
160062		- case 214: /* expr */
160063		- case 243: /* where_opt */
160064		- case 245: /* having_opt */
160065		- case 257: /* on_opt */
160066		- case 264: /* where_opt_ret */
160067		- case 275: /* case_operand */
160068		- case 277: /* case_else */
160069		- case 280: /* vinto */
160070		- case 287: /* when_clause */
160071		- case 292: /* key_opt */
160072		- case 308: /* filter_clause */
160073		-{
160074		-sqlite3ExprDelete(pParse->db, (yypminor->yy602));
160075		-}
160076		- break;
160077		- case 218: /* eidlist_opt */
160078		- case 228: /* sortlist */
160079		- case 229: /* eidlist */
160080		- case 241: /* selcollist */
160081		- case 244: /* groupby_opt */
160082		- case 246: /* orderby_opt */
160083		- case 250: /* nexprlist */
160084		- case 251: /* sclp */
160085		- case 259: /* exprlist */
160086		- case 265: /* setlist */
160087		- case 274: /* paren_exprlist */
160088		- case 276: /* case_exprlist */
160089		- case 307: /* part_opt */
160090		-{
160091		-sqlite3ExprListDelete(pParse->db, (yypminor->yy338));
160092		-}
160093		- break;
160094		- case 235: /* fullname */
160095		- case 242: /* from */
160096		- case 253: /* seltablist */
160097		- case 254: /* stl_prefix */
160098		- case 260: /* xfullname */
160099		-{
160100		-sqlite3SrcListDelete(pParse->db, (yypminor->yy291));
160101		-}
160102		- break;
160103		- case 238: /* wqlist */
160104		-{
160105		-sqlite3WithDelete(pParse->db, (yypminor->yy195));
160106		-}
160107		- break;
160108		- case 248: /* window_clause */
160109		- case 303: /* windowdefn_list */
160110		-{
160111		-sqlite3WindowListDelete(pParse->db, (yypminor->yy19));
160112		-}
160113		- break;
160114		- case 258: /* using_opt */
160115		- case 261: /* idlist */
160116		- case 267: /* idlist_opt */
160117		-{
160118		-sqlite3IdListDelete(pParse->db, (yypminor->yy288));
160119		-}
160120		- break;
160121		- case 270: /* filter_over */
160122		- case 304: /* windowdefn */
160123		- case 305: /* window */
160124		- case 306: /* frame_opt */
160125		- case 309: /* over_clause */
160126		-{
160127		-sqlite3WindowDelete(pParse->db, (yypminor->yy19));
160128		-}
160129		- break;
160130		- case 283: /* trigger_cmd_list */
160131		- case 288: /* trigger_cmd */
160132		-{
160133		-sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy483));
160134		-}
160135		- break;
160136		- case 285: /* trigger_event */
160137		-{
160138		-sqlite3IdListDelete(pParse->db, (yypminor->yy50).b);
160139		-}
160140		- break;
160141		- case 311: /* frame_bound */
160142		- case 312: /* frame_bound_s */
160143		- case 313: /* frame_bound_e */
160144		-{
160145		-sqlite3ExprDelete(pParse->db, (yypminor->yy113).pExpr);
	160217	+ case 203: /* select */
	160218	+ case 237: /* selectnowith */
	160219	+ case 238: /* oneselect */
	160220	+ case 250: /* values */
	160221	+{
	160222	+sqlite3SelectDelete(pParse->db, (yypminor->yy81));
	160223	+}
	160224	+ break;
	160225	+ case 214: /* term */
	160226	+ case 215: /* expr */
	160227	+ case 244: /* where_opt */
	160228	+ case 246: /* having_opt */
	160229	+ case 258: /* on_opt */
	160230	+ case 265: /* where_opt_ret */
	160231	+ case 276: /* case_operand */
	160232	+ case 278: /* case_else */
	160233	+ case 281: /* vinto */
	160234	+ case 288: /* when_clause */
	160235	+ case 293: /* key_opt */
	160236	+ case 309: /* filter_clause */
	160237	+{
	160238	+sqlite3ExprDelete(pParse->db, (yypminor->yy404));
	160239	+}
	160240	+ break;
	160241	+ case 219: /* eidlist_opt */
	160242	+ case 229: /* sortlist */
	160243	+ case 230: /* eidlist */
	160244	+ case 242: /* selcollist */
	160245	+ case 245: /* groupby_opt */
	160246	+ case 247: /* orderby_opt */
	160247	+ case 251: /* nexprlist */
	160248	+ case 252: /* sclp */
	160249	+ case 260: /* exprlist */
	160250	+ case 266: /* setlist */
	160251	+ case 275: /* paren_exprlist */
	160252	+ case 277: /* case_exprlist */
	160253	+ case 308: /* part_opt */
	160254	+{
	160255	+sqlite3ExprListDelete(pParse->db, (yypminor->yy70));
	160256	+}
	160257	+ break;
	160258	+ case 236: /* fullname */
	160259	+ case 243: /* from */
	160260	+ case 254: /* seltablist */
	160261	+ case 255: /* stl_prefix */
	160262	+ case 261: /* xfullname */
	160263	+{
	160264	+sqlite3SrcListDelete(pParse->db, (yypminor->yy153));
	160265	+}
	160266	+ break;
	160267	+ case 239: /* wqlist */
	160268	+{
	160269	+sqlite3WithDelete(pParse->db, (yypminor->yy103));
	160270	+}
	160271	+ break;
	160272	+ case 249: /* window_clause */
	160273	+ case 304: /* windowdefn_list */
	160274	+{
	160275	+sqlite3WindowListDelete(pParse->db, (yypminor->yy49));
	160276	+}
	160277	+ break;
	160278	+ case 259: /* using_opt */
	160279	+ case 262: /* idlist */
	160280	+ case 268: /* idlist_opt */
	160281	+{
	160282	+sqlite3IdListDelete(pParse->db, (yypminor->yy436));
	160283	+}
	160284	+ break;
	160285	+ case 271: /* filter_over */
	160286	+ case 305: /* windowdefn */
	160287	+ case 306: /* window */
	160288	+ case 307: /* frame_opt */
	160289	+ case 310: /* over_clause */
	160290	+{
	160291	+sqlite3WindowDelete(pParse->db, (yypminor->yy49));
	160292	+}
	160293	+ break;
	160294	+ case 284: /* trigger_cmd_list */
	160295	+ case 289: /* trigger_cmd */
	160296	+{
	160297	+sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy157));
	160298	+}
	160299	+ break;
	160300	+ case 286: /* trigger_event */
	160301	+{
	160302	+sqlite3IdListDelete(pParse->db, (yypminor->yy262).b);
	160303	+}
	160304	+ break;
	160305	+ case 312: /* frame_bound */
	160306	+ case 313: /* frame_bound_s */
	160307	+ case 314: /* frame_bound_e */
	160308	+{
	160309	+sqlite3ExprDelete(pParse->db, (yypminor->yy117).pExpr);
160146	160310	}
160147	160311	break;
160148	160312	/******* End destructor definitions ***************************************/
160149	160313	default: break; /* If no destructor action specified: do nothing */
160150	160314	}
		@@ -160431,408 +160595,408 @@
160431	160595	}
160432	160596
160433	160597	/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
160434	160598	** of that rule */
160435	160599	static const YYCODETYPE yyRuleInfoLhs[] = {
160436		- 187, /* (0) explain ::= EXPLAIN */
160437		- 187, /* (1) explain ::= EXPLAIN QUERY PLAN */
160438		- 186, /* (2) cmdx ::= cmd */
160439		- 188, /* (3) cmd ::= BEGIN transtype trans_opt */
160440		- 189, /* (4) transtype ::= */
160441		- 189, /* (5) transtype ::= DEFERRED */
160442		- 189, /* (6) transtype ::= IMMEDIATE */
160443		- 189, /* (7) transtype ::= EXCLUSIVE */
160444		- 188, /* (8) cmd ::= COMMIT\|END trans_opt */
160445		- 188, /* (9) cmd ::= ROLLBACK trans_opt */
160446		- 188, /* (10) cmd ::= SAVEPOINT nm */
160447		- 188, /* (11) cmd ::= RELEASE savepoint_opt nm */
160448		- 188, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
160449		- 193, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
160450		- 195, /* (14) createkw ::= CREATE */
160451		- 197, /* (15) ifnotexists ::= */
160452		- 197, /* (16) ifnotexists ::= IF NOT EXISTS */
160453		- 196, /* (17) temp ::= TEMP */
160454		- 196, /* (18) temp ::= */
160455		- 194, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */
160456		- 194, /* (20) create_table_args ::= AS select */
160457		- 201, /* (21) table_options ::= */
160458		- 201, /* (22) table_options ::= WITHOUT nm */
160459		- 203, /* (23) columnname ::= nm typetoken */
160460		- 205, /* (24) typetoken ::= */
160461		- 205, /* (25) typetoken ::= typename LP signed RP */
160462		- 205, /* (26) typetoken ::= typename LP signed COMMA signed RP */
160463		- 206, /* (27) typename ::= typename ID\|STRING */
160464		- 210, /* (28) scanpt ::= */
160465		- 211, /* (29) scantok ::= */
160466		- 212, /* (30) ccons ::= CONSTRAINT nm */
160467		- 212, /* (31) ccons ::= DEFAULT scantok term */
160468		- 212, /* (32) ccons ::= DEFAULT LP expr RP */
160469		- 212, /* (33) ccons ::= DEFAULT PLUS scantok term */
160470		- 212, /* (34) ccons ::= DEFAULT MINUS scantok term */
160471		- 212, /* (35) ccons ::= DEFAULT scantok ID\|INDEXED */
160472		- 212, /* (36) ccons ::= NOT NULL onconf */
160473		- 212, /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */
160474		- 212, /* (38) ccons ::= UNIQUE onconf */
160475		- 212, /* (39) ccons ::= CHECK LP expr RP */
160476		- 212, /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */
160477		- 212, /* (41) ccons ::= defer_subclause */
160478		- 212, /* (42) ccons ::= COLLATE ID\|STRING */
160479		- 221, /* (43) generated ::= LP expr RP */
160480		- 221, /* (44) generated ::= LP expr RP ID */
160481		- 217, /* (45) autoinc ::= */
160482		- 217, /* (46) autoinc ::= AUTOINCR */
160483		- 219, /* (47) refargs ::= */
160484		- 219, /* (48) refargs ::= refargs refarg */
160485		- 222, /* (49) refarg ::= MATCH nm */
160486		- 222, /* (50) refarg ::= ON INSERT refact */
160487		- 222, /* (51) refarg ::= ON DELETE refact */
160488		- 222, /* (52) refarg ::= ON UPDATE refact */
160489		- 223, /* (53) refact ::= SET NULL */
160490		- 223, /* (54) refact ::= SET DEFAULT */
160491		- 223, /* (55) refact ::= CASCADE */
160492		- 223, /* (56) refact ::= RESTRICT */
160493		- 223, /* (57) refact ::= NO ACTION */
160494		- 220, /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
160495		- 220, /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
160496		- 224, /* (60) init_deferred_pred_opt ::= */
160497		- 224, /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */
160498		- 224, /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
160499		- 200, /* (63) conslist_opt ::= */
160500		- 226, /* (64) tconscomma ::= COMMA */
160501		- 227, /* (65) tcons ::= CONSTRAINT nm */
160502		- 227, /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
160503		- 227, /* (67) tcons ::= UNIQUE LP sortlist RP onconf */
160504		- 227, /* (68) tcons ::= CHECK LP expr RP onconf */
160505		- 227, /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
160506		- 230, /* (70) defer_subclause_opt ::= */
160507		- 215, /* (71) onconf ::= */
160508		- 215, /* (72) onconf ::= ON CONFLICT resolvetype */
160509		- 231, /* (73) orconf ::= */
160510		- 231, /* (74) orconf ::= OR resolvetype */
160511		- 232, /* (75) resolvetype ::= IGNORE */
160512		- 232, /* (76) resolvetype ::= REPLACE */
160513		- 188, /* (77) cmd ::= DROP TABLE ifexists fullname */
160514		- 234, /* (78) ifexists ::= IF EXISTS */
160515		- 234, /* (79) ifexists ::= */
160516		- 188, /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
160517		- 188, /* (81) cmd ::= DROP VIEW ifexists fullname */
160518		- 188, /* (82) cmd ::= select */
160519		- 202, /* (83) select ::= WITH wqlist selectnowith */
160520		- 202, /* (84) select ::= WITH RECURSIVE wqlist selectnowith */
160521		- 202, /* (85) select ::= selectnowith */
160522		- 236, /* (86) selectnowith ::= selectnowith multiselect_op oneselect */
160523		- 239, /* (87) multiselect_op ::= UNION */
160524		- 239, /* (88) multiselect_op ::= UNION ALL */
160525		- 239, /* (89) multiselect_op ::= EXCEPT\|INTERSECT */
160526		- 237, /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
160527		- 237, /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
160528		- 249, /* (92) values ::= VALUES LP nexprlist RP */
160529		- 249, /* (93) values ::= values COMMA LP nexprlist RP */
160530		- 240, /* (94) distinct ::= DISTINCT */
160531		- 240, /* (95) distinct ::= ALL */
160532		- 240, /* (96) distinct ::= */
160533		- 251, /* (97) sclp ::= */
160534		- 241, /* (98) selcollist ::= sclp scanpt expr scanpt as */
160535		- 241, /* (99) selcollist ::= sclp scanpt STAR */
160536		- 241, /* (100) selcollist ::= sclp scanpt nm DOT STAR */
160537		- 252, /* (101) as ::= AS nm */
160538		- 252, /* (102) as ::= */
160539		- 242, /* (103) from ::= */
160540		- 242, /* (104) from ::= FROM seltablist */
160541		- 254, /* (105) stl_prefix ::= seltablist joinop */
160542		- 254, /* (106) stl_prefix ::= */
160543		- 253, /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
160544		- 253, /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
160545		- 253, /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
160546		- 253, /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
160547		- 198, /* (111) dbnm ::= */
160548		- 198, /* (112) dbnm ::= DOT nm */
160549		- 235, /* (113) fullname ::= nm */
160550		- 235, /* (114) fullname ::= nm DOT nm */
160551		- 260, /* (115) xfullname ::= nm */
160552		- 260, /* (116) xfullname ::= nm DOT nm */
160553		- 260, /* (117) xfullname ::= nm DOT nm AS nm */
160554		- 260, /* (118) xfullname ::= nm AS nm */
160555		- 255, /* (119) joinop ::= COMMA\|JOIN */
160556		- 255, /* (120) joinop ::= JOIN_KW JOIN */
160557		- 255, /* (121) joinop ::= JOIN_KW nm JOIN */
160558		- 255, /* (122) joinop ::= JOIN_KW nm nm JOIN */
160559		- 257, /* (123) on_opt ::= ON expr */
160560		- 257, /* (124) on_opt ::= */
160561		- 256, /* (125) indexed_opt ::= */
160562		- 256, /* (126) indexed_opt ::= INDEXED BY nm */
160563		- 256, /* (127) indexed_opt ::= NOT INDEXED */
160564		- 258, /* (128) using_opt ::= USING LP idlist RP */
160565		- 258, /* (129) using_opt ::= */
160566		- 246, /* (130) orderby_opt ::= */
160567		- 246, /* (131) orderby_opt ::= ORDER BY sortlist */
160568		- 228, /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */
160569		- 228, /* (133) sortlist ::= expr sortorder nulls */
160570		- 216, /* (134) sortorder ::= ASC */
160571		- 216, /* (135) sortorder ::= DESC */
160572		- 216, /* (136) sortorder ::= */
160573		- 262, /* (137) nulls ::= NULLS FIRST */
160574		- 262, /* (138) nulls ::= NULLS LAST */
160575		- 262, /* (139) nulls ::= */
160576		- 244, /* (140) groupby_opt ::= */
160577		- 244, /* (141) groupby_opt ::= GROUP BY nexprlist */
160578		- 245, /* (142) having_opt ::= */
160579		- 245, /* (143) having_opt ::= HAVING expr */
160580		- 247, /* (144) limit_opt ::= */
160581		- 247, /* (145) limit_opt ::= LIMIT expr */
160582		- 247, /* (146) limit_opt ::= LIMIT expr OFFSET expr */
160583		- 247, /* (147) limit_opt ::= LIMIT expr COMMA expr */
160584		- 188, /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
160585		- 243, /* (149) where_opt ::= */
160586		- 243, /* (150) where_opt ::= WHERE expr */
160587		- 264, /* (151) where_opt_ret ::= */
160588		- 264, /* (152) where_opt_ret ::= WHERE expr */
160589		- 264, /* (153) where_opt_ret ::= RETURNING selcollist */
160590		- 264, /* (154) where_opt_ret ::= WHERE expr RETURNING selcollist */
160591		- 188, /* (155) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
160592		- 265, /* (156) setlist ::= setlist COMMA nm EQ expr */
160593		- 265, /* (157) setlist ::= setlist COMMA LP idlist RP EQ expr */
160594		- 265, /* (158) setlist ::= nm EQ expr */
160595		- 265, /* (159) setlist ::= LP idlist RP EQ expr */
160596		- 188, /* (160) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
160597		- 188, /* (161) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
160598		- 268, /* (162) upsert ::= */
160599		- 268, /* (163) upsert ::= RETURNING selcollist */
160600		- 268, /* (164) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
160601		- 268, /* (165) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
160602		- 268, /* (166) upsert ::= ON CONFLICT DO NOTHING returning */
160603		- 268, /* (167) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
160604		- 269, /* (168) returning ::= RETURNING selcollist */
160605		- 266, /* (169) insert_cmd ::= INSERT orconf */
160606		- 266, /* (170) insert_cmd ::= REPLACE */
160607		- 267, /* (171) idlist_opt ::= */
160608		- 267, /* (172) idlist_opt ::= LP idlist RP */
160609		- 261, /* (173) idlist ::= idlist COMMA nm */
160610		- 261, /* (174) idlist ::= nm */
160611		- 214, /* (175) expr ::= LP expr RP */
160612		- 214, /* (176) expr ::= ID\|INDEXED */
160613		- 214, /* (177) expr ::= JOIN_KW */
160614		- 214, /* (178) expr ::= nm DOT nm */
160615		- 214, /* (179) expr ::= nm DOT nm DOT nm */
160616		- 213, /* (180) term ::= NULL\|FLOAT\|BLOB */
160617		- 213, /* (181) term ::= STRING */
160618		- 213, /* (182) term ::= INTEGER */
160619		- 214, /* (183) expr ::= VARIABLE */
160620		- 214, /* (184) expr ::= expr COLLATE ID\|STRING */
160621		- 214, /* (185) expr ::= CAST LP expr AS typetoken RP */
160622		- 214, /* (186) expr ::= ID\|INDEXED LP distinct exprlist RP */
160623		- 214, /* (187) expr ::= ID\|INDEXED LP STAR RP */
160624		- 214, /* (188) expr ::= ID\|INDEXED LP distinct exprlist RP filter_over */
160625		- 214, /* (189) expr ::= ID\|INDEXED LP STAR RP filter_over */
160626		- 213, /* (190) term ::= CTIME_KW */
160627		- 214, /* (191) expr ::= LP nexprlist COMMA expr RP */
160628		- 214, /* (192) expr ::= expr AND expr */
160629		- 214, /* (193) expr ::= expr OR expr */
160630		- 214, /* (194) expr ::= expr LT\|GT\|GE\|LE expr */
160631		- 214, /* (195) expr ::= expr EQ\|NE expr */
160632		- 214, /* (196) expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */
160633		- 214, /* (197) expr ::= expr PLUS\|MINUS expr */
160634		- 214, /* (198) expr ::= expr STAR\|SLASH\|REM expr */
160635		- 214, /* (199) expr ::= expr CONCAT expr */
160636		- 271, /* (200) likeop ::= NOT LIKE_KW\|MATCH */
160637		- 214, /* (201) expr ::= expr likeop expr */
160638		- 214, /* (202) expr ::= expr likeop expr ESCAPE expr */
160639		- 214, /* (203) expr ::= expr ISNULL\|NOTNULL */
160640		- 214, /* (204) expr ::= expr NOT NULL */
160641		- 214, /* (205) expr ::= expr IS expr */
160642		- 214, /* (206) expr ::= expr IS NOT expr */
160643		- 214, /* (207) expr ::= NOT expr */
160644		- 214, /* (208) expr ::= BITNOT expr */
160645		- 214, /* (209) expr ::= PLUS\|MINUS expr */
160646		- 272, /* (210) between_op ::= BETWEEN */
160647		- 272, /* (211) between_op ::= NOT BETWEEN */
160648		- 214, /* (212) expr ::= expr between_op expr AND expr */
160649		- 273, /* (213) in_op ::= IN */
160650		- 273, /* (214) in_op ::= NOT IN */
160651		- 214, /* (215) expr ::= expr in_op LP exprlist RP */
160652		- 214, /* (216) expr ::= LP select RP */
160653		- 214, /* (217) expr ::= expr in_op LP select RP */
160654		- 214, /* (218) expr ::= expr in_op nm dbnm paren_exprlist */
160655		- 214, /* (219) expr ::= EXISTS LP select RP */
160656		- 214, /* (220) expr ::= CASE case_operand case_exprlist case_else END */
160657		- 276, /* (221) case_exprlist ::= case_exprlist WHEN expr THEN expr */
160658		- 276, /* (222) case_exprlist ::= WHEN expr THEN expr */
160659		- 277, /* (223) case_else ::= ELSE expr */
160660		- 277, /* (224) case_else ::= */
160661		- 275, /* (225) case_operand ::= expr */
160662		- 275, /* (226) case_operand ::= */
160663		- 259, /* (227) exprlist ::= */
160664		- 250, /* (228) nexprlist ::= nexprlist COMMA expr */
160665		- 250, /* (229) nexprlist ::= expr */
160666		- 274, /* (230) paren_exprlist ::= */
160667		- 274, /* (231) paren_exprlist ::= LP exprlist RP */
160668		- 188, /* (232) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
160669		- 278, /* (233) uniqueflag ::= UNIQUE */
160670		- 278, /* (234) uniqueflag ::= */
160671		- 218, /* (235) eidlist_opt ::= */
160672		- 218, /* (236) eidlist_opt ::= LP eidlist RP */
160673		- 229, /* (237) eidlist ::= eidlist COMMA nm collate sortorder */
160674		- 229, /* (238) eidlist ::= nm collate sortorder */
160675		- 279, /* (239) collate ::= */
160676		- 279, /* (240) collate ::= COLLATE ID\|STRING */
160677		- 188, /* (241) cmd ::= DROP INDEX ifexists fullname */
160678		- 188, /* (242) cmd ::= VACUUM vinto */
160679		- 188, /* (243) cmd ::= VACUUM nm vinto */
160680		- 280, /* (244) vinto ::= INTO expr */
160681		- 280, /* (245) vinto ::= */
160682		- 188, /* (246) cmd ::= PRAGMA nm dbnm */
160683		- 188, /* (247) cmd ::= PRAGMA nm dbnm EQ nmnum */
160684		- 188, /* (248) cmd ::= PRAGMA nm dbnm LP nmnum RP */
160685		- 188, /* (249) cmd ::= PRAGMA nm dbnm EQ minus_num */
160686		- 188, /* (250) cmd ::= PRAGMA nm dbnm LP minus_num RP */
160687		- 208, /* (251) plus_num ::= PLUS INTEGER\|FLOAT */
160688		- 209, /* (252) minus_num ::= MINUS INTEGER\|FLOAT */
160689		- 188, /* (253) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
160690		- 282, /* (254) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
160691		- 284, /* (255) trigger_time ::= BEFORE\|AFTER */
160692		- 284, /* (256) trigger_time ::= INSTEAD OF */
160693		- 284, /* (257) trigger_time ::= */
160694		- 285, /* (258) trigger_event ::= DELETE\|INSERT */
160695		- 285, /* (259) trigger_event ::= UPDATE */
160696		- 285, /* (260) trigger_event ::= UPDATE OF idlist */
160697		- 287, /* (261) when_clause ::= */
160698		- 287, /* (262) when_clause ::= WHEN expr */
160699		- 283, /* (263) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
160700		- 283, /* (264) trigger_cmd_list ::= trigger_cmd SEMI */
160701		- 289, /* (265) trnm ::= nm DOT nm */
160702		- 290, /* (266) tridxby ::= INDEXED BY nm */
160703		- 290, /* (267) tridxby ::= NOT INDEXED */
160704		- 288, /* (268) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
160705		- 288, /* (269) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
160706		- 288, /* (270) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
160707		- 288, /* (271) trigger_cmd ::= scanpt select scanpt */
160708		- 214, /* (272) expr ::= RAISE LP IGNORE RP */
160709		- 214, /* (273) expr ::= RAISE LP raisetype COMMA nm RP */
160710		- 233, /* (274) raisetype ::= ROLLBACK */
160711		- 233, /* (275) raisetype ::= ABORT */
160712		- 233, /* (276) raisetype ::= FAIL */
160713		- 188, /* (277) cmd ::= DROP TRIGGER ifexists fullname */
160714		- 188, /* (278) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
160715		- 188, /* (279) cmd ::= DETACH database_kw_opt expr */
160716		- 292, /* (280) key_opt ::= */
160717		- 292, /* (281) key_opt ::= KEY expr */
160718		- 188, /* (282) cmd ::= REINDEX */
160719		- 188, /* (283) cmd ::= REINDEX nm dbnm */
160720		- 188, /* (284) cmd ::= ANALYZE */
160721		- 188, /* (285) cmd ::= ANALYZE nm dbnm */
160722		- 188, /* (286) cmd ::= ALTER TABLE fullname RENAME TO nm */
160723		- 188, /* (287) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
160724		- 188, /* (288) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
160725		- 293, /* (289) add_column_fullname ::= fullname */
160726		- 188, /* (290) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
160727		- 188, /* (291) cmd ::= create_vtab */
160728		- 188, /* (292) cmd ::= create_vtab LP vtabarglist RP */
160729		- 295, /* (293) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
160730		- 297, /* (294) vtabarg ::= */
160731		- 298, /* (295) vtabargtoken ::= ANY */
160732		- 298, /* (296) vtabargtoken ::= lp anylist RP */
160733		- 299, /* (297) lp ::= LP */
160734		- 263, /* (298) with ::= WITH wqlist */
160735		- 263, /* (299) with ::= WITH RECURSIVE wqlist */
160736		- 302, /* (300) wqas ::= AS */
160737		- 302, /* (301) wqas ::= AS MATERIALIZED */
160738		- 302, /* (302) wqas ::= AS NOT MATERIALIZED */
160739		- 301, /* (303) wqitem ::= nm eidlist_opt wqas LP select RP */
160740		- 238, /* (304) wqlist ::= wqitem */
160741		- 238, /* (305) wqlist ::= wqlist COMMA wqitem */
160742		- 303, /* (306) windowdefn_list ::= windowdefn */
160743		- 303, /* (307) windowdefn_list ::= windowdefn_list COMMA windowdefn */
160744		- 304, /* (308) windowdefn ::= nm AS LP window RP */
160745		- 305, /* (309) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
160746		- 305, /* (310) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
160747		- 305, /* (311) window ::= ORDER BY sortlist frame_opt */
160748		- 305, /* (312) window ::= nm ORDER BY sortlist frame_opt */
160749		- 305, /* (313) window ::= frame_opt */
160750		- 305, /* (314) window ::= nm frame_opt */
160751		- 306, /* (315) frame_opt ::= */
160752		- 306, /* (316) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
160753		- 306, /* (317) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
160754		- 310, /* (318) range_or_rows ::= RANGE\|ROWS\|GROUPS */
160755		- 312, /* (319) frame_bound_s ::= frame_bound */
160756		- 312, /* (320) frame_bound_s ::= UNBOUNDED PRECEDING */
160757		- 313, /* (321) frame_bound_e ::= frame_bound */
160758		- 313, /* (322) frame_bound_e ::= UNBOUNDED FOLLOWING */
160759		- 311, /* (323) frame_bound ::= expr PRECEDING\|FOLLOWING */
160760		- 311, /* (324) frame_bound ::= CURRENT ROW */
160761		- 314, /* (325) frame_exclude_opt ::= */
160762		- 314, /* (326) frame_exclude_opt ::= EXCLUDE frame_exclude */
160763		- 315, /* (327) frame_exclude ::= NO OTHERS */
160764		- 315, /* (328) frame_exclude ::= CURRENT ROW */
160765		- 315, /* (329) frame_exclude ::= GROUP\|TIES */
160766		- 248, /* (330) window_clause ::= WINDOW windowdefn_list */
160767		- 270, /* (331) filter_over ::= filter_clause over_clause */
160768		- 270, /* (332) filter_over ::= over_clause */
160769		- 270, /* (333) filter_over ::= filter_clause */
160770		- 309, /* (334) over_clause ::= OVER LP window RP */
160771		- 309, /* (335) over_clause ::= OVER nm */
160772		- 308, /* (336) filter_clause ::= FILTER LP WHERE expr RP */
160773		- 183, /* (337) input ::= cmdlist */
160774		- 184, /* (338) cmdlist ::= cmdlist ecmd */
160775		- 184, /* (339) cmdlist ::= ecmd */
160776		- 185, /* (340) ecmd ::= SEMI */
160777		- 185, /* (341) ecmd ::= cmdx SEMI */
160778		- 185, /* (342) ecmd ::= explain cmdx SEMI */
160779		- 190, /* (343) trans_opt ::= */
160780		- 190, /* (344) trans_opt ::= TRANSACTION */
160781		- 190, /* (345) trans_opt ::= TRANSACTION nm */
160782		- 192, /* (346) savepoint_opt ::= SAVEPOINT */
160783		- 192, /* (347) savepoint_opt ::= */
160784		- 188, /* (348) cmd ::= create_table create_table_args */
160785		- 199, /* (349) columnlist ::= columnlist COMMA columnname carglist */
160786		- 199, /* (350) columnlist ::= columnname carglist */
160787		- 191, /* (351) nm ::= ID\|INDEXED */
160788		- 191, /* (352) nm ::= STRING */
160789		- 191, /* (353) nm ::= JOIN_KW */
160790		- 205, /* (354) typetoken ::= typename */
160791		- 206, /* (355) typename ::= ID\|STRING */
160792		- 207, /* (356) signed ::= plus_num */
160793		- 207, /* (357) signed ::= minus_num */
160794		- 204, /* (358) carglist ::= carglist ccons */
160795		- 204, /* (359) carglist ::= */
160796		- 212, /* (360) ccons ::= NULL onconf */
160797		- 212, /* (361) ccons ::= GENERATED ALWAYS AS generated */
160798		- 212, /* (362) ccons ::= AS generated */
160799		- 200, /* (363) conslist_opt ::= COMMA conslist */
160800		- 225, /* (364) conslist ::= conslist tconscomma tcons */
160801		- 225, /* (365) conslist ::= tcons */
160802		- 226, /* (366) tconscomma ::= */
160803		- 230, /* (367) defer_subclause_opt ::= defer_subclause */
160804		- 232, /* (368) resolvetype ::= raisetype */
160805		- 236, /* (369) selectnowith ::= oneselect */
160806		- 237, /* (370) oneselect ::= values */
160807		- 251, /* (371) sclp ::= selcollist COMMA */
160808		- 252, /* (372) as ::= ID\|STRING */
160809		- 269, /* (373) returning ::= */
160810		- 214, /* (374) expr ::= term */
160811		- 271, /* (375) likeop ::= LIKE_KW\|MATCH */
160812		- 259, /* (376) exprlist ::= nexprlist */
160813		- 281, /* (377) nmnum ::= plus_num */
160814		- 281, /* (378) nmnum ::= nm */
160815		- 281, /* (379) nmnum ::= ON */
160816		- 281, /* (380) nmnum ::= DELETE */
160817		- 281, /* (381) nmnum ::= DEFAULT */
160818		- 208, /* (382) plus_num ::= INTEGER\|FLOAT */
160819		- 286, /* (383) foreach_clause ::= */
160820		- 286, /* (384) foreach_clause ::= FOR EACH ROW */
160821		- 289, /* (385) trnm ::= nm */
160822		- 290, /* (386) tridxby ::= */
160823		- 291, /* (387) database_kw_opt ::= DATABASE */
160824		- 291, /* (388) database_kw_opt ::= */
160825		- 294, /* (389) kwcolumn_opt ::= */
160826		- 294, /* (390) kwcolumn_opt ::= COLUMNKW */
160827		- 296, /* (391) vtabarglist ::= vtabarg */
160828		- 296, /* (392) vtabarglist ::= vtabarglist COMMA vtabarg */
160829		- 297, /* (393) vtabarg ::= vtabarg vtabargtoken */
160830		- 300, /* (394) anylist ::= */
160831		- 300, /* (395) anylist ::= anylist LP anylist RP */
160832		- 300, /* (396) anylist ::= anylist ANY */
160833		- 263, /* (397) with ::= */
	160600	+ 188, /* (0) explain ::= EXPLAIN */
	160601	+ 188, /* (1) explain ::= EXPLAIN QUERY PLAN */
	160602	+ 187, /* (2) cmdx ::= cmd */
	160603	+ 189, /* (3) cmd ::= BEGIN transtype trans_opt */
	160604	+ 190, /* (4) transtype ::= */
	160605	+ 190, /* (5) transtype ::= DEFERRED */
	160606	+ 190, /* (6) transtype ::= IMMEDIATE */
	160607	+ 190, /* (7) transtype ::= EXCLUSIVE */
	160608	+ 189, /* (8) cmd ::= COMMIT\|END trans_opt */
	160609	+ 189, /* (9) cmd ::= ROLLBACK trans_opt */
	160610	+ 189, /* (10) cmd ::= SAVEPOINT nm */
	160611	+ 189, /* (11) cmd ::= RELEASE savepoint_opt nm */
	160612	+ 189, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
	160613	+ 194, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
	160614	+ 196, /* (14) createkw ::= CREATE */
	160615	+ 198, /* (15) ifnotexists ::= */
	160616	+ 198, /* (16) ifnotexists ::= IF NOT EXISTS */
	160617	+ 197, /* (17) temp ::= TEMP */
	160618	+ 197, /* (18) temp ::= */
	160619	+ 195, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */
	160620	+ 195, /* (20) create_table_args ::= AS select */
	160621	+ 202, /* (21) table_options ::= */
	160622	+ 202, /* (22) table_options ::= WITHOUT nm */
	160623	+ 204, /* (23) columnname ::= nm typetoken */
	160624	+ 206, /* (24) typetoken ::= */
	160625	+ 206, /* (25) typetoken ::= typename LP signed RP */
	160626	+ 206, /* (26) typetoken ::= typename LP signed COMMA signed RP */
	160627	+ 207, /* (27) typename ::= typename ID\|STRING */
	160628	+ 211, /* (28) scanpt ::= */
	160629	+ 212, /* (29) scantok ::= */
	160630	+ 213, /* (30) ccons ::= CONSTRAINT nm */
	160631	+ 213, /* (31) ccons ::= DEFAULT scantok term */
	160632	+ 213, /* (32) ccons ::= DEFAULT LP expr RP */
	160633	+ 213, /* (33) ccons ::= DEFAULT PLUS scantok term */
	160634	+ 213, /* (34) ccons ::= DEFAULT MINUS scantok term */
	160635	+ 213, /* (35) ccons ::= DEFAULT scantok ID\|INDEXED */
	160636	+ 213, /* (36) ccons ::= NOT NULL onconf */
	160637	+ 213, /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */
	160638	+ 213, /* (38) ccons ::= UNIQUE onconf */
	160639	+ 213, /* (39) ccons ::= CHECK LP expr RP */
	160640	+ 213, /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */
	160641	+ 213, /* (41) ccons ::= defer_subclause */
	160642	+ 213, /* (42) ccons ::= COLLATE ID\|STRING */
	160643	+ 222, /* (43) generated ::= LP expr RP */
	160644	+ 222, /* (44) generated ::= LP expr RP ID */
	160645	+ 218, /* (45) autoinc ::= */
	160646	+ 218, /* (46) autoinc ::= AUTOINCR */
	160647	+ 220, /* (47) refargs ::= */
	160648	+ 220, /* (48) refargs ::= refargs refarg */
	160649	+ 223, /* (49) refarg ::= MATCH nm */
	160650	+ 223, /* (50) refarg ::= ON INSERT refact */
	160651	+ 223, /* (51) refarg ::= ON DELETE refact */
	160652	+ 223, /* (52) refarg ::= ON UPDATE refact */
	160653	+ 224, /* (53) refact ::= SET NULL */
	160654	+ 224, /* (54) refact ::= SET DEFAULT */
	160655	+ 224, /* (55) refact ::= CASCADE */
	160656	+ 224, /* (56) refact ::= RESTRICT */
	160657	+ 224, /* (57) refact ::= NO ACTION */
	160658	+ 221, /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
	160659	+ 221, /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
	160660	+ 225, /* (60) init_deferred_pred_opt ::= */
	160661	+ 225, /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */
	160662	+ 225, /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
	160663	+ 201, /* (63) conslist_opt ::= */
	160664	+ 227, /* (64) tconscomma ::= COMMA */
	160665	+ 228, /* (65) tcons ::= CONSTRAINT nm */
	160666	+ 228, /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
	160667	+ 228, /* (67) tcons ::= UNIQUE LP sortlist RP onconf */
	160668	+ 228, /* (68) tcons ::= CHECK LP expr RP onconf */
	160669	+ 228, /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
	160670	+ 231, /* (70) defer_subclause_opt ::= */
	160671	+ 216, /* (71) onconf ::= */
	160672	+ 216, /* (72) onconf ::= ON CONFLICT resolvetype */
	160673	+ 232, /* (73) orconf ::= */
	160674	+ 232, /* (74) orconf ::= OR resolvetype */
	160675	+ 233, /* (75) resolvetype ::= IGNORE */
	160676	+ 233, /* (76) resolvetype ::= REPLACE */
	160677	+ 189, /* (77) cmd ::= DROP TABLE ifexists fullname */
	160678	+ 235, /* (78) ifexists ::= IF EXISTS */
	160679	+ 235, /* (79) ifexists ::= */
	160680	+ 189, /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
	160681	+ 189, /* (81) cmd ::= DROP VIEW ifexists fullname */
	160682	+ 189, /* (82) cmd ::= select */
	160683	+ 203, /* (83) select ::= WITH wqlist selectnowith */
	160684	+ 203, /* (84) select ::= WITH RECURSIVE wqlist selectnowith */
	160685	+ 203, /* (85) select ::= selectnowith */
	160686	+ 237, /* (86) selectnowith ::= selectnowith multiselect_op oneselect */
	160687	+ 240, /* (87) multiselect_op ::= UNION */
	160688	+ 240, /* (88) multiselect_op ::= UNION ALL */
	160689	+ 240, /* (89) multiselect_op ::= EXCEPT\|INTERSECT */
	160690	+ 238, /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
	160691	+ 238, /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
	160692	+ 250, /* (92) values ::= VALUES LP nexprlist RP */
	160693	+ 250, /* (93) values ::= values COMMA LP nexprlist RP */
	160694	+ 241, /* (94) distinct ::= DISTINCT */
	160695	+ 241, /* (95) distinct ::= ALL */
	160696	+ 241, /* (96) distinct ::= */
	160697	+ 252, /* (97) sclp ::= */
	160698	+ 242, /* (98) selcollist ::= sclp scanpt expr scanpt as */
	160699	+ 242, /* (99) selcollist ::= sclp scanpt STAR */
	160700	+ 242, /* (100) selcollist ::= sclp scanpt nm DOT STAR */
	160701	+ 253, /* (101) as ::= AS nm */
	160702	+ 253, /* (102) as ::= */
	160703	+ 243, /* (103) from ::= */
	160704	+ 243, /* (104) from ::= FROM seltablist */
	160705	+ 255, /* (105) stl_prefix ::= seltablist joinop */
	160706	+ 255, /* (106) stl_prefix ::= */
	160707	+ 254, /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
	160708	+ 254, /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
	160709	+ 254, /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
	160710	+ 254, /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
	160711	+ 199, /* (111) dbnm ::= */
	160712	+ 199, /* (112) dbnm ::= DOT nm */
	160713	+ 236, /* (113) fullname ::= nm */
	160714	+ 236, /* (114) fullname ::= nm DOT nm */
	160715	+ 261, /* (115) xfullname ::= nm */
	160716	+ 261, /* (116) xfullname ::= nm DOT nm */
	160717	+ 261, /* (117) xfullname ::= nm DOT nm AS nm */
	160718	+ 261, /* (118) xfullname ::= nm AS nm */
	160719	+ 256, /* (119) joinop ::= COMMA\|JOIN */
	160720	+ 256, /* (120) joinop ::= JOIN_KW JOIN */
	160721	+ 256, /* (121) joinop ::= JOIN_KW nm JOIN */
	160722	+ 256, /* (122) joinop ::= JOIN_KW nm nm JOIN */
	160723	+ 258, /* (123) on_opt ::= ON expr */
	160724	+ 258, /* (124) on_opt ::= */
	160725	+ 257, /* (125) indexed_opt ::= */
	160726	+ 257, /* (126) indexed_opt ::= INDEXED BY nm */
	160727	+ 257, /* (127) indexed_opt ::= NOT INDEXED */
	160728	+ 259, /* (128) using_opt ::= USING LP idlist RP */
	160729	+ 259, /* (129) using_opt ::= */
	160730	+ 247, /* (130) orderby_opt ::= */
	160731	+ 247, /* (131) orderby_opt ::= ORDER BY sortlist */
	160732	+ 229, /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */
	160733	+ 229, /* (133) sortlist ::= expr sortorder nulls */
	160734	+ 217, /* (134) sortorder ::= ASC */
	160735	+ 217, /* (135) sortorder ::= DESC */
	160736	+ 217, /* (136) sortorder ::= */
	160737	+ 263, /* (137) nulls ::= NULLS FIRST */
	160738	+ 263, /* (138) nulls ::= NULLS LAST */
	160739	+ 263, /* (139) nulls ::= */
	160740	+ 245, /* (140) groupby_opt ::= */
	160741	+ 245, /* (141) groupby_opt ::= GROUP BY nexprlist */
	160742	+ 246, /* (142) having_opt ::= */
	160743	+ 246, /* (143) having_opt ::= HAVING expr */
	160744	+ 248, /* (144) limit_opt ::= */
	160745	+ 248, /* (145) limit_opt ::= LIMIT expr */
	160746	+ 248, /* (146) limit_opt ::= LIMIT expr OFFSET expr */
	160747	+ 248, /* (147) limit_opt ::= LIMIT expr COMMA expr */
	160748	+ 189, /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
	160749	+ 244, /* (149) where_opt ::= */
	160750	+ 244, /* (150) where_opt ::= WHERE expr */
	160751	+ 265, /* (151) where_opt_ret ::= */
	160752	+ 265, /* (152) where_opt_ret ::= WHERE expr */
	160753	+ 265, /* (153) where_opt_ret ::= RETURNING selcollist */
	160754	+ 265, /* (154) where_opt_ret ::= WHERE expr RETURNING selcollist */
	160755	+ 189, /* (155) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
	160756	+ 266, /* (156) setlist ::= setlist COMMA nm EQ expr */
	160757	+ 266, /* (157) setlist ::= setlist COMMA LP idlist RP EQ expr */
	160758	+ 266, /* (158) setlist ::= nm EQ expr */
	160759	+ 266, /* (159) setlist ::= LP idlist RP EQ expr */
	160760	+ 189, /* (160) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
	160761	+ 189, /* (161) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
	160762	+ 269, /* (162) upsert ::= */
	160763	+ 269, /* (163) upsert ::= RETURNING selcollist */
	160764	+ 269, /* (164) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
	160765	+ 269, /* (165) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
	160766	+ 269, /* (166) upsert ::= ON CONFLICT DO NOTHING returning */
	160767	+ 269, /* (167) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
	160768	+ 270, /* (168) returning ::= RETURNING selcollist */
	160769	+ 267, /* (169) insert_cmd ::= INSERT orconf */
	160770	+ 267, /* (170) insert_cmd ::= REPLACE */
	160771	+ 268, /* (171) idlist_opt ::= */
	160772	+ 268, /* (172) idlist_opt ::= LP idlist RP */
	160773	+ 262, /* (173) idlist ::= idlist COMMA nm */
	160774	+ 262, /* (174) idlist ::= nm */
	160775	+ 215, /* (175) expr ::= LP expr RP */
	160776	+ 215, /* (176) expr ::= ID\|INDEXED */
	160777	+ 215, /* (177) expr ::= JOIN_KW */
	160778	+ 215, /* (178) expr ::= nm DOT nm */
	160779	+ 215, /* (179) expr ::= nm DOT nm DOT nm */
	160780	+ 214, /* (180) term ::= NULL\|FLOAT\|BLOB */
	160781	+ 214, /* (181) term ::= STRING */
	160782	+ 214, /* (182) term ::= INTEGER */
	160783	+ 215, /* (183) expr ::= VARIABLE */
	160784	+ 215, /* (184) expr ::= expr COLLATE ID\|STRING */
	160785	+ 215, /* (185) expr ::= CAST LP expr AS typetoken RP */
	160786	+ 215, /* (186) expr ::= ID\|INDEXED LP distinct exprlist RP */
	160787	+ 215, /* (187) expr ::= ID\|INDEXED LP STAR RP */
	160788	+ 215, /* (188) expr ::= ID\|INDEXED LP distinct exprlist RP filter_over */
	160789	+ 215, /* (189) expr ::= ID\|INDEXED LP STAR RP filter_over */
	160790	+ 214, /* (190) term ::= CTIME_KW */
	160791	+ 215, /* (191) expr ::= LP nexprlist COMMA expr RP */
	160792	+ 215, /* (192) expr ::= expr AND expr */
	160793	+ 215, /* (193) expr ::= expr OR expr */
	160794	+ 215, /* (194) expr ::= expr LT\|GT\|GE\|LE expr */
	160795	+ 215, /* (195) expr ::= expr EQ\|NE expr */
	160796	+ 215, /* (196) expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */
	160797	+ 215, /* (197) expr ::= expr PLUS\|MINUS expr */
	160798	+ 215, /* (198) expr ::= expr STAR\|SLASH\|REM expr */
	160799	+ 215, /* (199) expr ::= expr CONCAT expr */
	160800	+ 272, /* (200) likeop ::= NOT LIKE_KW\|MATCH */
	160801	+ 215, /* (201) expr ::= expr likeop expr */
	160802	+ 215, /* (202) expr ::= expr likeop expr ESCAPE expr */
	160803	+ 215, /* (203) expr ::= expr ISNULL\|NOTNULL */
	160804	+ 215, /* (204) expr ::= expr NOT NULL */
	160805	+ 215, /* (205) expr ::= expr IS expr */
	160806	+ 215, /* (206) expr ::= expr IS NOT expr */
	160807	+ 215, /* (207) expr ::= NOT expr */
	160808	+ 215, /* (208) expr ::= BITNOT expr */
	160809	+ 215, /* (209) expr ::= PLUS\|MINUS expr */
	160810	+ 273, /* (210) between_op ::= BETWEEN */
	160811	+ 273, /* (211) between_op ::= NOT BETWEEN */
	160812	+ 215, /* (212) expr ::= expr between_op expr AND expr */
	160813	+ 274, /* (213) in_op ::= IN */
	160814	+ 274, /* (214) in_op ::= NOT IN */
	160815	+ 215, /* (215) expr ::= expr in_op LP exprlist RP */
	160816	+ 215, /* (216) expr ::= LP select RP */
	160817	+ 215, /* (217) expr ::= expr in_op LP select RP */
	160818	+ 215, /* (218) expr ::= expr in_op nm dbnm paren_exprlist */
	160819	+ 215, /* (219) expr ::= EXISTS LP select RP */
	160820	+ 215, /* (220) expr ::= CASE case_operand case_exprlist case_else END */
	160821	+ 277, /* (221) case_exprlist ::= case_exprlist WHEN expr THEN expr */
	160822	+ 277, /* (222) case_exprlist ::= WHEN expr THEN expr */
	160823	+ 278, /* (223) case_else ::= ELSE expr */
	160824	+ 278, /* (224) case_else ::= */
	160825	+ 276, /* (225) case_operand ::= expr */
	160826	+ 276, /* (226) case_operand ::= */
	160827	+ 260, /* (227) exprlist ::= */
	160828	+ 251, /* (228) nexprlist ::= nexprlist COMMA expr */
	160829	+ 251, /* (229) nexprlist ::= expr */
	160830	+ 275, /* (230) paren_exprlist ::= */
	160831	+ 275, /* (231) paren_exprlist ::= LP exprlist RP */
	160832	+ 189, /* (232) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
	160833	+ 279, /* (233) uniqueflag ::= UNIQUE */
	160834	+ 279, /* (234) uniqueflag ::= */
	160835	+ 219, /* (235) eidlist_opt ::= */
	160836	+ 219, /* (236) eidlist_opt ::= LP eidlist RP */
	160837	+ 230, /* (237) eidlist ::= eidlist COMMA nm collate sortorder */
	160838	+ 230, /* (238) eidlist ::= nm collate sortorder */
	160839	+ 280, /* (239) collate ::= */
	160840	+ 280, /* (240) collate ::= COLLATE ID\|STRING */
	160841	+ 189, /* (241) cmd ::= DROP INDEX ifexists fullname */
	160842	+ 189, /* (242) cmd ::= VACUUM vinto */
	160843	+ 189, /* (243) cmd ::= VACUUM nm vinto */
	160844	+ 281, /* (244) vinto ::= INTO expr */
	160845	+ 281, /* (245) vinto ::= */
	160846	+ 189, /* (246) cmd ::= PRAGMA nm dbnm */
	160847	+ 189, /* (247) cmd ::= PRAGMA nm dbnm EQ nmnum */
	160848	+ 189, /* (248) cmd ::= PRAGMA nm dbnm LP nmnum RP */
	160849	+ 189, /* (249) cmd ::= PRAGMA nm dbnm EQ minus_num */
	160850	+ 189, /* (250) cmd ::= PRAGMA nm dbnm LP minus_num RP */
	160851	+ 209, /* (251) plus_num ::= PLUS INTEGER\|FLOAT */
	160852	+ 210, /* (252) minus_num ::= MINUS INTEGER\|FLOAT */
	160853	+ 189, /* (253) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
	160854	+ 283, /* (254) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
	160855	+ 285, /* (255) trigger_time ::= BEFORE\|AFTER */
	160856	+ 285, /* (256) trigger_time ::= INSTEAD OF */
	160857	+ 285, /* (257) trigger_time ::= */
	160858	+ 286, /* (258) trigger_event ::= DELETE\|INSERT */
	160859	+ 286, /* (259) trigger_event ::= UPDATE */
	160860	+ 286, /* (260) trigger_event ::= UPDATE OF idlist */
	160861	+ 288, /* (261) when_clause ::= */
	160862	+ 288, /* (262) when_clause ::= WHEN expr */
	160863	+ 284, /* (263) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
	160864	+ 284, /* (264) trigger_cmd_list ::= trigger_cmd SEMI */
	160865	+ 290, /* (265) trnm ::= nm DOT nm */
	160866	+ 291, /* (266) tridxby ::= INDEXED BY nm */
	160867	+ 291, /* (267) tridxby ::= NOT INDEXED */
	160868	+ 289, /* (268) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
	160869	+ 289, /* (269) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
	160870	+ 289, /* (270) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
	160871	+ 289, /* (271) trigger_cmd ::= scanpt select scanpt */
	160872	+ 215, /* (272) expr ::= RAISE LP IGNORE RP */
	160873	+ 215, /* (273) expr ::= RAISE LP raisetype COMMA nm RP */
	160874	+ 234, /* (274) raisetype ::= ROLLBACK */
	160875	+ 234, /* (275) raisetype ::= ABORT */
	160876	+ 234, /* (276) raisetype ::= FAIL */
	160877	+ 189, /* (277) cmd ::= DROP TRIGGER ifexists fullname */
	160878	+ 189, /* (278) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
	160879	+ 189, /* (279) cmd ::= DETACH database_kw_opt expr */
	160880	+ 293, /* (280) key_opt ::= */
	160881	+ 293, /* (281) key_opt ::= KEY expr */
	160882	+ 189, /* (282) cmd ::= REINDEX */
	160883	+ 189, /* (283) cmd ::= REINDEX nm dbnm */
	160884	+ 189, /* (284) cmd ::= ANALYZE */
	160885	+ 189, /* (285) cmd ::= ANALYZE nm dbnm */
	160886	+ 189, /* (286) cmd ::= ALTER TABLE fullname RENAME TO nm */
	160887	+ 189, /* (287) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
	160888	+ 189, /* (288) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
	160889	+ 294, /* (289) add_column_fullname ::= fullname */
	160890	+ 189, /* (290) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
	160891	+ 189, /* (291) cmd ::= create_vtab */
	160892	+ 189, /* (292) cmd ::= create_vtab LP vtabarglist RP */
	160893	+ 296, /* (293) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
	160894	+ 298, /* (294) vtabarg ::= */
	160895	+ 299, /* (295) vtabargtoken ::= ANY */
	160896	+ 299, /* (296) vtabargtoken ::= lp anylist RP */
	160897	+ 300, /* (297) lp ::= LP */
	160898	+ 264, /* (298) with ::= WITH wqlist */
	160899	+ 264, /* (299) with ::= WITH RECURSIVE wqlist */
	160900	+ 303, /* (300) wqas ::= AS */
	160901	+ 303, /* (301) wqas ::= AS MATERIALIZED */
	160902	+ 303, /* (302) wqas ::= AS NOT MATERIALIZED */
	160903	+ 302, /* (303) wqitem ::= nm eidlist_opt wqas LP select RP */
	160904	+ 239, /* (304) wqlist ::= wqitem */
	160905	+ 239, /* (305) wqlist ::= wqlist COMMA wqitem */
	160906	+ 304, /* (306) windowdefn_list ::= windowdefn */
	160907	+ 304, /* (307) windowdefn_list ::= windowdefn_list COMMA windowdefn */
	160908	+ 305, /* (308) windowdefn ::= nm AS LP window RP */
	160909	+ 306, /* (309) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
	160910	+ 306, /* (310) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
	160911	+ 306, /* (311) window ::= ORDER BY sortlist frame_opt */
	160912	+ 306, /* (312) window ::= nm ORDER BY sortlist frame_opt */
	160913	+ 306, /* (313) window ::= frame_opt */
	160914	+ 306, /* (314) window ::= nm frame_opt */
	160915	+ 307, /* (315) frame_opt ::= */
	160916	+ 307, /* (316) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
	160917	+ 307, /* (317) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
	160918	+ 311, /* (318) range_or_rows ::= RANGE\|ROWS\|GROUPS */
	160919	+ 313, /* (319) frame_bound_s ::= frame_bound */
	160920	+ 313, /* (320) frame_bound_s ::= UNBOUNDED PRECEDING */
	160921	+ 314, /* (321) frame_bound_e ::= frame_bound */
	160922	+ 314, /* (322) frame_bound_e ::= UNBOUNDED FOLLOWING */
	160923	+ 312, /* (323) frame_bound ::= expr PRECEDING\|FOLLOWING */
	160924	+ 312, /* (324) frame_bound ::= CURRENT ROW */
	160925	+ 315, /* (325) frame_exclude_opt ::= */
	160926	+ 315, /* (326) frame_exclude_opt ::= EXCLUDE frame_exclude */
	160927	+ 316, /* (327) frame_exclude ::= NO OTHERS */
	160928	+ 316, /* (328) frame_exclude ::= CURRENT ROW */
	160929	+ 316, /* (329) frame_exclude ::= GROUP\|TIES */
	160930	+ 249, /* (330) window_clause ::= WINDOW windowdefn_list */
	160931	+ 271, /* (331) filter_over ::= filter_clause over_clause */
	160932	+ 271, /* (332) filter_over ::= over_clause */
	160933	+ 271, /* (333) filter_over ::= filter_clause */
	160934	+ 310, /* (334) over_clause ::= OVER LP window RP */
	160935	+ 310, /* (335) over_clause ::= OVER nm */
	160936	+ 309, /* (336) filter_clause ::= FILTER LP WHERE expr RP */
	160937	+ 184, /* (337) input ::= cmdlist */
	160938	+ 185, /* (338) cmdlist ::= cmdlist ecmd */
	160939	+ 185, /* (339) cmdlist ::= ecmd */
	160940	+ 186, /* (340) ecmd ::= SEMI */
	160941	+ 186, /* (341) ecmd ::= cmdx SEMI */
	160942	+ 186, /* (342) ecmd ::= explain cmdx SEMI */
	160943	+ 191, /* (343) trans_opt ::= */
	160944	+ 191, /* (344) trans_opt ::= TRANSACTION */
	160945	+ 191, /* (345) trans_opt ::= TRANSACTION nm */
	160946	+ 193, /* (346) savepoint_opt ::= SAVEPOINT */
	160947	+ 193, /* (347) savepoint_opt ::= */
	160948	+ 189, /* (348) cmd ::= create_table create_table_args */
	160949	+ 200, /* (349) columnlist ::= columnlist COMMA columnname carglist */
	160950	+ 200, /* (350) columnlist ::= columnname carglist */
	160951	+ 192, /* (351) nm ::= ID\|INDEXED */
	160952	+ 192, /* (352) nm ::= STRING */
	160953	+ 192, /* (353) nm ::= JOIN_KW */
	160954	+ 206, /* (354) typetoken ::= typename */
	160955	+ 207, /* (355) typename ::= ID\|STRING */
	160956	+ 208, /* (356) signed ::= plus_num */
	160957	+ 208, /* (357) signed ::= minus_num */
	160958	+ 205, /* (358) carglist ::= carglist ccons */
	160959	+ 205, /* (359) carglist ::= */
	160960	+ 213, /* (360) ccons ::= NULL onconf */
	160961	+ 213, /* (361) ccons ::= GENERATED ALWAYS AS generated */
	160962	+ 213, /* (362) ccons ::= AS generated */
	160963	+ 201, /* (363) conslist_opt ::= COMMA conslist */
	160964	+ 226, /* (364) conslist ::= conslist tconscomma tcons */
	160965	+ 226, /* (365) conslist ::= tcons */
	160966	+ 227, /* (366) tconscomma ::= */
	160967	+ 231, /* (367) defer_subclause_opt ::= defer_subclause */
	160968	+ 233, /* (368) resolvetype ::= raisetype */
	160969	+ 237, /* (369) selectnowith ::= oneselect */
	160970	+ 238, /* (370) oneselect ::= values */
	160971	+ 252, /* (371) sclp ::= selcollist COMMA */
	160972	+ 253, /* (372) as ::= ID\|STRING */
	160973	+ 270, /* (373) returning ::= */
	160974	+ 215, /* (374) expr ::= term */
	160975	+ 272, /* (375) likeop ::= LIKE_KW\|MATCH */
	160976	+ 260, /* (376) exprlist ::= nexprlist */
	160977	+ 282, /* (377) nmnum ::= plus_num */
	160978	+ 282, /* (378) nmnum ::= nm */
	160979	+ 282, /* (379) nmnum ::= ON */
	160980	+ 282, /* (380) nmnum ::= DELETE */
	160981	+ 282, /* (381) nmnum ::= DEFAULT */
	160982	+ 209, /* (382) plus_num ::= INTEGER\|FLOAT */
	160983	+ 287, /* (383) foreach_clause ::= */
	160984	+ 287, /* (384) foreach_clause ::= FOR EACH ROW */
	160985	+ 290, /* (385) trnm ::= nm */
	160986	+ 291, /* (386) tridxby ::= */
	160987	+ 292, /* (387) database_kw_opt ::= DATABASE */
	160988	+ 292, /* (388) database_kw_opt ::= */
	160989	+ 295, /* (389) kwcolumn_opt ::= */
	160990	+ 295, /* (390) kwcolumn_opt ::= COLUMNKW */
	160991	+ 297, /* (391) vtabarglist ::= vtabarg */
	160992	+ 297, /* (392) vtabarglist ::= vtabarglist COMMA vtabarg */
	160993	+ 298, /* (393) vtabarg ::= vtabarg vtabargtoken */
	160994	+ 301, /* (394) anylist ::= */
	160995	+ 301, /* (395) anylist ::= anylist LP anylist RP */
	160996	+ 301, /* (396) anylist ::= anylist ANY */
	160997	+ 264, /* (397) with ::= */
160834	160998	};
160835	160999
160836	161000	/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
160837	161001	** of symbols on the right-hand side of that rule. */
160838	161002	static const signed char yyRuleInfoNRhs[] = {
		@@ -161283,20 +161447,20 @@
161283	161447	break;
161284	161448	case 2: /* cmdx ::= cmd */
161285	161449	{ sqlite3FinishCoding(pParse); }
161286	161450	break;
161287	161451	case 3: /* cmd ::= BEGIN transtype trans_opt */
161288		-{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy60);}
	161452	+{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy376);}
161289	161453	break;
161290	161454	case 4: /* transtype ::= */
161291		-{yymsp[1].minor.yy60 = TK_DEFERRED;}
	161455	+{yymsp[1].minor.yy376 = TK_DEFERRED;}
161292	161456	break;
161293	161457	case 5: /* transtype ::= DEFERRED */
161294	161458	case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
161295	161459	case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
161296	161460	case 318: /* range_or_rows ::= RANGE\|ROWS\|GROUPS */ yytestcase(yyruleno==318);
161297		-{yymsp[0].minor.yy60 = yymsp[0].major; /A-overwrites-X/}
	161461	+{yymsp[0].minor.yy376 = yymsp[0].major; /A-overwrites-X/}
161298	161462	break;
161299	161463	case 8: /* cmd ::= COMMIT\|END trans_opt */
161300	161464	case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
161301	161465	{sqlite3EndTransaction(pParse,yymsp[-1].major);}
161302	161466	break;
		@@ -161315,11 +161479,11 @@
161315	161479	sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
161316	161480	}
161317	161481	break;
161318	161482	case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
161319	161483	{
161320		- sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy60,0,0,yymsp[-2].minor.yy60);
	161484	+ sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy376,0,0,yymsp[-2].minor.yy376);
161321	161485	}
161322	161486	break;
161323	161487	case 14: /* createkw ::= CREATE */
161324	161488	{disableLookaside(pParse);}
161325	161489	break;
		@@ -161330,35 +161494,35 @@
161330	161494	case 60: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==60);
161331	161495	case 70: /* defer_subclause_opt ::= */ yytestcase(yyruleno==70);
161332	161496	case 79: /* ifexists ::= */ yytestcase(yyruleno==79);
161333	161497	case 96: /* distinct ::= */ yytestcase(yyruleno==96);
161334	161498	case 239: /* collate ::= */ yytestcase(yyruleno==239);
161335		-{yymsp[1].minor.yy60 = 0;}
	161499	+{yymsp[1].minor.yy376 = 0;}
161336	161500	break;
161337	161501	case 16: /* ifnotexists ::= IF NOT EXISTS */
161338		-{yymsp[-2].minor.yy60 = 1;}
	161502	+{yymsp[-2].minor.yy376 = 1;}
161339	161503	break;
161340	161504	case 17: /* temp ::= TEMP */
161341		-{yymsp[0].minor.yy60 = pParse->db->init.busy==0;}
	161505	+{yymsp[0].minor.yy376 = pParse->db->init.busy==0;}
161342	161506	break;
161343	161507	case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_options */
161344	161508	{
161345		- sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy60,0);
	161509	+ sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy376,0);
161346	161510	}
161347	161511	break;
161348	161512	case 20: /* create_table_args ::= AS select */
161349	161513	{
161350		- sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy307);
161351		- sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy307);
	161514	+ sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy81);
	161515	+ sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy81);
161352	161516	}
161353	161517	break;
161354	161518	case 22: /* table_options ::= WITHOUT nm */
161355	161519	{
161356	161520	if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
161357		- yymsp[-1].minor.yy60 = TF_WithoutRowid \| TF_NoVisibleRowid;
	161521	+ yymsp[-1].minor.yy376 = TF_WithoutRowid \| TF_NoVisibleRowid;
161358	161522	}else{
161359		- yymsp[-1].minor.yy60 = 0;
	161523	+ yymsp[-1].minor.yy376 = 0;
161360	161524	sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
161361	161525	}
161362	161526	}
161363	161527	break;
161364	161528	case 23: /* columnname ::= nm typetoken */
		@@ -161383,11 +161547,11 @@
161383	161547	{yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
161384	161548	break;
161385	161549	case 28: /* scanpt ::= */
161386	161550	{
161387	161551	assert( yyLookahead!=YYNOCODE );
161388		- yymsp[1].minor.yy528 = yyLookaheadToken.z;
	161552	+ yymsp[1].minor.yy504 = yyLookaheadToken.z;
161389	161553	}
161390	161554	break;
161391	161555	case 29: /* scantok ::= */
161392	161556	{
161393	161557	assert( yyLookahead!=YYNOCODE );
		@@ -161397,21 +161561,21 @@
161397	161561	case 30: /* ccons ::= CONSTRAINT nm */
161398	161562	case 65: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==65);
161399	161563	{pParse->constraintName = yymsp[0].minor.yy0;}
161400	161564	break;
161401	161565	case 31: /* ccons ::= DEFAULT scantok term */
161402		-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy602,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
	161566	+{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy404,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
161403	161567	break;
161404	161568	case 32: /* ccons ::= DEFAULT LP expr RP */
161405		-{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy602,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
	161569	+{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy404,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
161406	161570	break;
161407	161571	case 33: /* ccons ::= DEFAULT PLUS scantok term */
161408		-{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy602,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
	161572	+{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy404,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
161409	161573	break;
161410	161574	case 34: /* ccons ::= DEFAULT MINUS scantok term */
161411	161575	{
161412		- Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy602, 0);
	161576	+ Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy404, 0);
161413	161577	sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
161414	161578	}
161415	161579	break;
161416	161580	case 35: /* ccons ::= DEFAULT scantok ID\|INDEXED */
161417	161581	{
		@@ -161422,259 +161586,259 @@
161422	161586	}
161423	161587	sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
161424	161588	}
161425	161589	break;
161426	161590	case 36: /* ccons ::= NOT NULL onconf */
161427		-{sqlite3AddNotNull(pParse, yymsp[0].minor.yy60);}
	161591	+{sqlite3AddNotNull(pParse, yymsp[0].minor.yy376);}
161428	161592	break;
161429	161593	case 37: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
161430		-{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy60,yymsp[0].minor.yy60,yymsp[-2].minor.yy60);}
	161594	+{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy376,yymsp[0].minor.yy376,yymsp[-2].minor.yy376);}
161431	161595	break;
161432	161596	case 38: /* ccons ::= UNIQUE onconf */
161433		-{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy60,0,0,0,0,
	161597	+{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy376,0,0,0,0,
161434	161598	SQLITE_IDXTYPE_UNIQUE);}
161435	161599	break;
161436	161600	case 39: /* ccons ::= CHECK LP expr RP */
161437		-{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy602,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
	161601	+{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy404,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
161438	161602	break;
161439	161603	case 40: /* ccons ::= REFERENCES nm eidlist_opt refargs */
161440		-{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy338,yymsp[0].minor.yy60);}
	161604	+{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy70,yymsp[0].minor.yy376);}
161441	161605	break;
161442	161606	case 41: /* ccons ::= defer_subclause */
161443		-{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy60);}
	161607	+{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy376);}
161444	161608	break;
161445	161609	case 42: /* ccons ::= COLLATE ID\|STRING */
161446	161610	{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
161447	161611	break;
161448	161612	case 43: /* generated ::= LP expr RP */
161449		-{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy602,0);}
	161613	+{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy404,0);}
161450	161614	break;
161451	161615	case 44: /* generated ::= LP expr RP ID */
161452		-{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy602,&yymsp[0].minor.yy0);}
	161616	+{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy404,&yymsp[0].minor.yy0);}
161453	161617	break;
161454	161618	case 46: /* autoinc ::= AUTOINCR */
161455		-{yymsp[0].minor.yy60 = 1;}
	161619	+{yymsp[0].minor.yy376 = 1;}
161456	161620	break;
161457	161621	case 47: /* refargs ::= */
161458		-{ yymsp[1].minor.yy60 = OE_None0x0101; / EV: R-19803-45884 */}
	161622	+{ yymsp[1].minor.yy376 = OE_None0x0101; / EV: R-19803-45884 */}
161459	161623	break;
161460	161624	case 48: /* refargs ::= refargs refarg */
161461		-{ yymsp[-1].minor.yy60 = (yymsp[-1].minor.yy60 & ~yymsp[0].minor.yy615.mask) \| yymsp[0].minor.yy615.value; }
	161625	+{ yymsp[-1].minor.yy376 = (yymsp[-1].minor.yy376 & ~yymsp[0].minor.yy139.mask) \| yymsp[0].minor.yy139.value; }
161462	161626	break;
161463	161627	case 49: /* refarg ::= MATCH nm */
161464		-{ yymsp[-1].minor.yy615.value = 0; yymsp[-1].minor.yy615.mask = 0x000000; }
	161628	+{ yymsp[-1].minor.yy139.value = 0; yymsp[-1].minor.yy139.mask = 0x000000; }
161465	161629	break;
161466	161630	case 50: /* refarg ::= ON INSERT refact */
161467		-{ yymsp[-2].minor.yy615.value = 0; yymsp[-2].minor.yy615.mask = 0x000000; }
	161631	+{ yymsp[-2].minor.yy139.value = 0; yymsp[-2].minor.yy139.mask = 0x000000; }
161468	161632	break;
161469	161633	case 51: /* refarg ::= ON DELETE refact */
161470		-{ yymsp[-2].minor.yy615.value = yymsp[0].minor.yy60; yymsp[-2].minor.yy615.mask = 0x0000ff; }
	161634	+{ yymsp[-2].minor.yy139.value = yymsp[0].minor.yy376; yymsp[-2].minor.yy139.mask = 0x0000ff; }
161471	161635	break;
161472	161636	case 52: /* refarg ::= ON UPDATE refact */
161473		-{ yymsp[-2].minor.yy615.value = yymsp[0].minor.yy60<<8; yymsp[-2].minor.yy615.mask = 0x00ff00; }
	161637	+{ yymsp[-2].minor.yy139.value = yymsp[0].minor.yy376<<8; yymsp[-2].minor.yy139.mask = 0x00ff00; }
161474	161638	break;
161475	161639	case 53: /* refact ::= SET NULL */
161476		-{ yymsp[-1].minor.yy60 = OE_SetNull; /* EV: R-33326-45252 */}
	161640	+{ yymsp[-1].minor.yy376 = OE_SetNull; /* EV: R-33326-45252 */}
161477	161641	break;
161478	161642	case 54: /* refact ::= SET DEFAULT */
161479		-{ yymsp[-1].minor.yy60 = OE_SetDflt; /* EV: R-33326-45252 */}
	161643	+{ yymsp[-1].minor.yy376 = OE_SetDflt; /* EV: R-33326-45252 */}
161480	161644	break;
161481	161645	case 55: /* refact ::= CASCADE */
161482		-{ yymsp[0].minor.yy60 = OE_Cascade; /* EV: R-33326-45252 */}
	161646	+{ yymsp[0].minor.yy376 = OE_Cascade; /* EV: R-33326-45252 */}
161483	161647	break;
161484	161648	case 56: /* refact ::= RESTRICT */
161485		-{ yymsp[0].minor.yy60 = OE_Restrict; /* EV: R-33326-45252 */}
	161649	+{ yymsp[0].minor.yy376 = OE_Restrict; /* EV: R-33326-45252 */}
161486	161650	break;
161487	161651	case 57: /* refact ::= NO ACTION */
161488		-{ yymsp[-1].minor.yy60 = OE_None; /* EV: R-33326-45252 */}
	161652	+{ yymsp[-1].minor.yy376 = OE_None; /* EV: R-33326-45252 */}
161489	161653	break;
161490	161654	case 58: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
161491		-{yymsp[-2].minor.yy60 = 0;}
	161655	+{yymsp[-2].minor.yy376 = 0;}
161492	161656	break;
161493	161657	case 59: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
161494	161658	case 74: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==74);
161495	161659	case 169: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==169);
161496		-{yymsp[-1].minor.yy60 = yymsp[0].minor.yy60;}
	161660	+{yymsp[-1].minor.yy376 = yymsp[0].minor.yy376;}
161497	161661	break;
161498	161662	case 61: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
161499	161663	case 78: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==78);
161500	161664	case 211: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==211);
161501	161665	case 214: /* in_op ::= NOT IN */ yytestcase(yyruleno==214);
161502	161666	case 240: /* collate ::= COLLATE ID\|STRING */ yytestcase(yyruleno==240);
161503		-{yymsp[-1].minor.yy60 = 1;}
	161667	+{yymsp[-1].minor.yy376 = 1;}
161504	161668	break;
161505	161669	case 62: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
161506		-{yymsp[-1].minor.yy60 = 0;}
	161670	+{yymsp[-1].minor.yy376 = 0;}
161507	161671	break;
161508	161672	case 64: /* tconscomma ::= COMMA */
161509	161673	{pParse->constraintName.n = 0;}
161510	161674	break;
161511	161675	case 66: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
161512		-{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy338,yymsp[0].minor.yy60,yymsp[-2].minor.yy60,0);}
	161676	+{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy70,yymsp[0].minor.yy376,yymsp[-2].minor.yy376,0);}
161513	161677	break;
161514	161678	case 67: /* tcons ::= UNIQUE LP sortlist RP onconf */
161515		-{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy338,yymsp[0].minor.yy60,0,0,0,0,
	161679	+{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy70,yymsp[0].minor.yy376,0,0,0,0,
161516	161680	SQLITE_IDXTYPE_UNIQUE);}
161517	161681	break;
161518	161682	case 68: /* tcons ::= CHECK LP expr RP onconf */
161519		-{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy602,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
	161683	+{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy404,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
161520	161684	break;
161521	161685	case 69: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
161522	161686	{
161523		- sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy338, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy338, yymsp[-1].minor.yy60);
161524		- sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy60);
	161687	+ sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy70, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy70, yymsp[-1].minor.yy376);
	161688	+ sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy376);
161525	161689	}
161526	161690	break;
161527	161691	case 71: /* onconf ::= */
161528	161692	case 73: /* orconf ::= */ yytestcase(yyruleno==73);
161529		-{yymsp[1].minor.yy60 = OE_Default;}
	161693	+{yymsp[1].minor.yy376 = OE_Default;}
161530	161694	break;
161531	161695	case 72: /* onconf ::= ON CONFLICT resolvetype */
161532		-{yymsp[-2].minor.yy60 = yymsp[0].minor.yy60;}
	161696	+{yymsp[-2].minor.yy376 = yymsp[0].minor.yy376;}
161533	161697	break;
161534	161698	case 75: /* resolvetype ::= IGNORE */
161535		-{yymsp[0].minor.yy60 = OE_Ignore;}
	161699	+{yymsp[0].minor.yy376 = OE_Ignore;}
161536	161700	break;
161537	161701	case 76: /* resolvetype ::= REPLACE */
161538	161702	case 170: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==170);
161539		-{yymsp[0].minor.yy60 = OE_Replace;}
	161703	+{yymsp[0].minor.yy376 = OE_Replace;}
161540	161704	break;
161541	161705	case 77: /* cmd ::= DROP TABLE ifexists fullname */
161542	161706	{
161543		- sqlite3DropTable(pParse, yymsp[0].minor.yy291, 0, yymsp[-1].minor.yy60);
	161707	+ sqlite3DropTable(pParse, yymsp[0].minor.yy153, 0, yymsp[-1].minor.yy376);
161544	161708	}
161545	161709	break;
161546	161710	case 80: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
161547	161711	{
161548		- sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy338, yymsp[0].minor.yy307, yymsp[-7].minor.yy60, yymsp[-5].minor.yy60);
	161712	+ sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy70, yymsp[0].minor.yy81, yymsp[-7].minor.yy376, yymsp[-5].minor.yy376);
161549	161713	}
161550	161714	break;
161551	161715	case 81: /* cmd ::= DROP VIEW ifexists fullname */
161552	161716	{
161553		- sqlite3DropTable(pParse, yymsp[0].minor.yy291, 1, yymsp[-1].minor.yy60);
	161717	+ sqlite3DropTable(pParse, yymsp[0].minor.yy153, 1, yymsp[-1].minor.yy376);
161554	161718	}
161555	161719	break;
161556	161720	case 82: /* cmd ::= select */
161557	161721	{
161558	161722	SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
161559		- sqlite3Select(pParse, yymsp[0].minor.yy307, &dest);
161560		- sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy307);
	161723	+ sqlite3Select(pParse, yymsp[0].minor.yy81, &dest);
	161724	+ sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy81);
161561	161725	}
161562	161726	break;
161563	161727	case 83: /* select ::= WITH wqlist selectnowith */
161564		-{yymsp[-2].minor.yy307 = attachWithToSelect(pParse,yymsp[0].minor.yy307,yymsp[-1].minor.yy195);}
	161728	+{yymsp[-2].minor.yy81 = attachWithToSelect(pParse,yymsp[0].minor.yy81,yymsp[-1].minor.yy103);}
161565	161729	break;
161566	161730	case 84: /* select ::= WITH RECURSIVE wqlist selectnowith */
161567		-{yymsp[-3].minor.yy307 = attachWithToSelect(pParse,yymsp[0].minor.yy307,yymsp[-1].minor.yy195);}
	161731	+{yymsp[-3].minor.yy81 = attachWithToSelect(pParse,yymsp[0].minor.yy81,yymsp[-1].minor.yy103);}
161568	161732	break;
161569	161733	case 85: /* select ::= selectnowith */
161570	161734	{
161571		- Select *p = yymsp[0].minor.yy307;
	161735	+ Select *p = yymsp[0].minor.yy81;
161572	161736	if( p ){
161573	161737	parserDoubleLinkSelect(pParse, p);
161574	161738	}
161575		- yymsp[0].minor.yy307 = p; /A-overwrites-X/
	161739	+ yymsp[0].minor.yy81 = p; /A-overwrites-X/
161576	161740	}
161577	161741	break;
161578	161742	case 86: /* selectnowith ::= selectnowith multiselect_op oneselect */
161579	161743	{
161580		- Select *pRhs = yymsp[0].minor.yy307;
161581		- Select *pLhs = yymsp[-2].minor.yy307;
	161744	+ Select *pRhs = yymsp[0].minor.yy81;
	161745	+ Select *pLhs = yymsp[-2].minor.yy81;
161582	161746	if( pRhs && pRhs->pPrior ){
161583	161747	SrcList *pFrom;
161584	161748	Token x;
161585	161749	x.n = 0;
161586	161750	parserDoubleLinkSelect(pParse, pRhs);
161587	161751	pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);
161588	161752	pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
161589	161753	}
161590	161754	if( pRhs ){
161591		- pRhs->op = (u8)yymsp[-1].minor.yy60;
	161755	+ pRhs->op = (u8)yymsp[-1].minor.yy376;
161592	161756	pRhs->pPrior = pLhs;
161593	161757	if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
161594	161758	pRhs->selFlags &= ~SF_MultiValue;
161595		- if( yymsp[-1].minor.yy60!=TK_ALL ) pParse->hasCompound = 1;
	161759	+ if( yymsp[-1].minor.yy376!=TK_ALL ) pParse->hasCompound = 1;
161596	161760	}else{
161597	161761	sqlite3SelectDelete(pParse->db, pLhs);
161598	161762	}
161599		- yymsp[-2].minor.yy307 = pRhs;
	161763	+ yymsp[-2].minor.yy81 = pRhs;
161600	161764	}
161601	161765	break;
161602	161766	case 87: /* multiselect_op ::= UNION */
161603	161767	case 89: /* multiselect_op ::= EXCEPT\|INTERSECT */ yytestcase(yyruleno==89);
161604		-{yymsp[0].minor.yy60 = yymsp[0].major; /A-overwrites-OP/}
	161768	+{yymsp[0].minor.yy376 = yymsp[0].major; /A-overwrites-OP/}
161605	161769	break;
161606	161770	case 88: /* multiselect_op ::= UNION ALL */
161607		-{yymsp[-1].minor.yy60 = TK_ALL;}
	161771	+{yymsp[-1].minor.yy376 = TK_ALL;}
161608	161772	break;
161609	161773	case 90: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
161610	161774	{
161611		- yymsp[-8].minor.yy307 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy338,yymsp[-5].minor.yy291,yymsp[-4].minor.yy602,yymsp[-3].minor.yy338,yymsp[-2].minor.yy602,yymsp[-1].minor.yy338,yymsp[-7].minor.yy60,yymsp[0].minor.yy602);
	161775	+ yymsp[-8].minor.yy81 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy70,yymsp[-5].minor.yy153,yymsp[-4].minor.yy404,yymsp[-3].minor.yy70,yymsp[-2].minor.yy404,yymsp[-1].minor.yy70,yymsp[-7].minor.yy376,yymsp[0].minor.yy404);
161612	161776	}
161613	161777	break;
161614	161778	case 91: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
161615	161779	{
161616		- yymsp[-9].minor.yy307 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy338,yymsp[-6].minor.yy291,yymsp[-5].minor.yy602,yymsp[-4].minor.yy338,yymsp[-3].minor.yy602,yymsp[-1].minor.yy338,yymsp[-8].minor.yy60,yymsp[0].minor.yy602);
161617		- if( yymsp[-9].minor.yy307 ){
161618		- yymsp[-9].minor.yy307->pWinDefn = yymsp[-2].minor.yy19;
	161780	+ yymsp[-9].minor.yy81 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy70,yymsp[-6].minor.yy153,yymsp[-5].minor.yy404,yymsp[-4].minor.yy70,yymsp[-3].minor.yy404,yymsp[-1].minor.yy70,yymsp[-8].minor.yy376,yymsp[0].minor.yy404);
	161781	+ if( yymsp[-9].minor.yy81 ){
	161782	+ yymsp[-9].minor.yy81->pWinDefn = yymsp[-2].minor.yy49;
161619	161783	}else{
161620		- sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy19);
	161784	+ sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy49);
161621	161785	}
161622	161786	}
161623	161787	break;
161624	161788	case 92: /* values ::= VALUES LP nexprlist RP */
161625	161789	{
161626		- yymsp[-3].minor.yy307 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy338,0,0,0,0,0,SF_Values,0);
	161790	+ yymsp[-3].minor.yy81 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy70,0,0,0,0,0,SF_Values,0);
161627	161791	}
161628	161792	break;
161629	161793	case 93: /* values ::= values COMMA LP nexprlist RP */
161630	161794	{
161631		- Select pRight, pLeft = yymsp[-4].minor.yy307;
161632		- pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy338,0,0,0,0,0,SF_Values\|SF_MultiValue,0);
	161795	+ Select pRight, pLeft = yymsp[-4].minor.yy81;
	161796	+ pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy70,0,0,0,0,0,SF_Values\|SF_MultiValue,0);
161633	161797	if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
161634	161798	if( pRight ){
161635	161799	pRight->op = TK_ALL;
161636	161800	pRight->pPrior = pLeft;
161637		- yymsp[-4].minor.yy307 = pRight;
	161801	+ yymsp[-4].minor.yy81 = pRight;
161638	161802	}else{
161639		- yymsp[-4].minor.yy307 = pLeft;
	161803	+ yymsp[-4].minor.yy81 = pLeft;
161640	161804	}
161641	161805	}
161642	161806	break;
161643	161807	case 94: /* distinct ::= DISTINCT */
161644		-{yymsp[0].minor.yy60 = SF_Distinct;}
	161808	+{yymsp[0].minor.yy376 = SF_Distinct;}
161645	161809	break;
161646	161810	case 95: /* distinct ::= ALL */
161647		-{yymsp[0].minor.yy60 = SF_All;}
	161811	+{yymsp[0].minor.yy376 = SF_All;}
161648	161812	break;
161649	161813	case 97: /* sclp ::= */
161650	161814	case 130: /* orderby_opt ::= */ yytestcase(yyruleno==130);
161651	161815	case 140: /* groupby_opt ::= */ yytestcase(yyruleno==140);
161652	161816	case 227: /* exprlist ::= */ yytestcase(yyruleno==227);
161653	161817	case 230: /* paren_exprlist ::= */ yytestcase(yyruleno==230);
161654	161818	case 235: /* eidlist_opt ::= */ yytestcase(yyruleno==235);
161655		-{yymsp[1].minor.yy338 = 0;}
	161819	+{yymsp[1].minor.yy70 = 0;}
161656	161820	break;
161657	161821	case 98: /* selcollist ::= sclp scanpt expr scanpt as */
161658	161822	{
161659		- yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy338, yymsp[-2].minor.yy602);
161660		- if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy338, &yymsp[0].minor.yy0, 1);
161661		- sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy338,yymsp[-3].minor.yy528,yymsp[-1].minor.yy528);
	161823	+ yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy70, yymsp[-2].minor.yy404);
	161824	+ if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy70, &yymsp[0].minor.yy0, 1);
	161825	+ sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy70,yymsp[-3].minor.yy504,yymsp[-1].minor.yy504);
161662	161826	}
161663	161827	break;
161664	161828	case 99: /* selcollist ::= sclp scanpt STAR */
161665	161829	{
161666	161830	Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
161667		- yymsp[-2].minor.yy338 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy338, p);
	161831	+ yymsp[-2].minor.yy70 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy70, p);
161668	161832	}
161669	161833	break;
161670	161834	case 100: /* selcollist ::= sclp scanpt nm DOT STAR */
161671	161835	{
161672	161836	Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
161673	161837	Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
161674	161838	Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
161675		- yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy338, pDot);
	161839	+ yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy70, pDot);
161676	161840	}
161677	161841	break;
161678	161842	case 101: /* as ::= AS nm */
161679	161843	case 112: /* dbnm ::= DOT nm */ yytestcase(yyruleno==112);
161680	161844	case 251: /* plus_num ::= PLUS INTEGER\|FLOAT */ yytestcase(yyruleno==251);
		@@ -161681,49 +161845,49 @@
161681	161845	case 252: /* minus_num ::= MINUS INTEGER\|FLOAT */ yytestcase(yyruleno==252);
161682	161846	{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
161683	161847	break;
161684	161848	case 103: /* from ::= */
161685	161849	case 106: /* stl_prefix ::= */ yytestcase(yyruleno==106);
161686		-{yymsp[1].minor.yy291 = 0;}
	161850	+{yymsp[1].minor.yy153 = 0;}
161687	161851	break;
161688	161852	case 104: /* from ::= FROM seltablist */
161689	161853	{
161690		- yymsp[-1].minor.yy291 = yymsp[0].minor.yy291;
161691		- sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy291);
	161854	+ yymsp[-1].minor.yy153 = yymsp[0].minor.yy153;
	161855	+ sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy153);
161692	161856	}
161693	161857	break;
161694	161858	case 105: /* stl_prefix ::= seltablist joinop */
161695	161859	{
161696		- if( ALWAYS(yymsp[-1].minor.yy291 && yymsp[-1].minor.yy291->nSrc>0) ) yymsp[-1].minor.yy291->a[yymsp[-1].minor.yy291->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy60;
	161860	+ if( ALWAYS(yymsp[-1].minor.yy153 && yymsp[-1].minor.yy153->nSrc>0) ) yymsp[-1].minor.yy153->a[yymsp[-1].minor.yy153->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy376;
161697	161861	}
161698	161862	break;
161699	161863	case 107: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
161700	161864	{
161701		- yymsp[-6].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy291,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
161702		- sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy291, &yymsp[-2].minor.yy0);
	161865	+ yymsp[-6].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy153,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
	161866	+ sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy153, &yymsp[-2].minor.yy0);
161703	161867	}
161704	161868	break;
161705	161869	case 108: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
161706	161870	{
161707		- yymsp[-8].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy291,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
161708		- sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy291, yymsp[-4].minor.yy338);
	161871	+ yymsp[-8].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy153,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
	161872	+ sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy153, yymsp[-4].minor.yy70);
161709	161873	}
161710	161874	break;
161711	161875	case 109: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
161712	161876	{
161713		- yymsp[-6].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy291,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy307,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
	161877	+ yymsp[-6].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy153,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy81,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
161714	161878	}
161715	161879	break;
161716	161880	case 110: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
161717	161881	{
161718		- if( yymsp[-6].minor.yy291==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy602==0 && yymsp[0].minor.yy288==0 ){
161719		- yymsp[-6].minor.yy291 = yymsp[-4].minor.yy291;
161720		- }else if( yymsp[-4].minor.yy291->nSrc==1 ){
161721		- yymsp[-6].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy291,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
161722		- if( yymsp[-6].minor.yy291 ){
161723		- SrcItem *pNew = &yymsp[-6].minor.yy291->a[yymsp[-6].minor.yy291->nSrc-1];
161724		- SrcItem *pOld = yymsp[-4].minor.yy291->a;
	161882	+ if( yymsp[-6].minor.yy153==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy404==0 && yymsp[0].minor.yy436==0 ){
	161883	+ yymsp[-6].minor.yy153 = yymsp[-4].minor.yy153;
	161884	+ }else if( yymsp[-4].minor.yy153->nSrc==1 ){
	161885	+ yymsp[-6].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy153,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
	161886	+ if( yymsp[-6].minor.yy153 ){
	161887	+ SrcItem *pNew = &yymsp[-6].minor.yy153->a[yymsp[-6].minor.yy153->nSrc-1];
	161888	+ SrcItem *pOld = yymsp[-4].minor.yy153->a;
161725	161889	pNew->zName = pOld->zName;
161726	161890	pNew->zDatabase = pOld->zDatabase;
161727	161891	pNew->pSelect = pOld->pSelect;
161728	161892	if( pOld->fg.isTabFunc ){
161729	161893	pNew->u1.pFuncArg = pOld->u1.pFuncArg;
		@@ -161732,240 +161896,240 @@
161732	161896	pNew->fg.isTabFunc = 1;
161733	161897	}
161734	161898	pOld->zName = pOld->zDatabase = 0;
161735	161899	pOld->pSelect = 0;
161736	161900	}
161737		- sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy291);
	161901	+ sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy153);
161738	161902	}else{
161739	161903	Select *pSubquery;
161740		- sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy291);
161741		- pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy291,0,0,0,0,SF_NestedFrom,0);
161742		- yymsp[-6].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy291,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
	161904	+ sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy153);
	161905	+ pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy153,0,0,0,0,SF_NestedFrom,0);
	161906	+ yymsp[-6].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy153,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
161743	161907	}
161744	161908	}
161745	161909	break;
161746	161910	case 111: /* dbnm ::= */
161747	161911	case 125: /* indexed_opt ::= */ yytestcase(yyruleno==125);
161748	161912	{yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
161749	161913	break;
161750	161914	case 113: /* fullname ::= nm */
161751	161915	{
161752		- yylhsminor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
161753		- if( IN_RENAME_OBJECT && yylhsminor.yy291 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy291->a[0].zName, &yymsp[0].minor.yy0);
	161916	+ yylhsminor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
	161917	+ if( IN_RENAME_OBJECT && yylhsminor.yy153 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy153->a[0].zName, &yymsp[0].minor.yy0);
161754	161918	}
161755		- yymsp[0].minor.yy291 = yylhsminor.yy291;
	161919	+ yymsp[0].minor.yy153 = yylhsminor.yy153;
161756	161920	break;
161757	161921	case 114: /* fullname ::= nm DOT nm */
161758	161922	{
161759		- yylhsminor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
161760		- if( IN_RENAME_OBJECT && yylhsminor.yy291 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy291->a[0].zName, &yymsp[0].minor.yy0);
	161923	+ yylhsminor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
	161924	+ if( IN_RENAME_OBJECT && yylhsminor.yy153 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy153->a[0].zName, &yymsp[0].minor.yy0);
161761	161925	}
161762		- yymsp[-2].minor.yy291 = yylhsminor.yy291;
	161926	+ yymsp[-2].minor.yy153 = yylhsminor.yy153;
161763	161927	break;
161764	161928	case 115: /* xfullname ::= nm */
161765		-{yymsp[0].minor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /A-overwrites-X/}
	161929	+{yymsp[0].minor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /A-overwrites-X/}
161766	161930	break;
161767	161931	case 116: /* xfullname ::= nm DOT nm */
161768		-{yymsp[-2].minor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/}
	161932	+{yymsp[-2].minor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/}
161769	161933	break;
161770	161934	case 117: /* xfullname ::= nm DOT nm AS nm */
161771	161935	{
161772		- yymsp[-4].minor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /A-overwrites-X/
161773		- if( yymsp[-4].minor.yy291 ) yymsp[-4].minor.yy291->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
	161936	+ yymsp[-4].minor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /A-overwrites-X/
	161937	+ if( yymsp[-4].minor.yy153 ) yymsp[-4].minor.yy153->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
161774	161938	}
161775	161939	break;
161776	161940	case 118: /* xfullname ::= nm AS nm */
161777	161941	{
161778		- yymsp[-2].minor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /A-overwrites-X/
161779		- if( yymsp[-2].minor.yy291 ) yymsp[-2].minor.yy291->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
	161942	+ yymsp[-2].minor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /A-overwrites-X/
	161943	+ if( yymsp[-2].minor.yy153 ) yymsp[-2].minor.yy153->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
161780	161944	}
161781	161945	break;
161782	161946	case 119: /* joinop ::= COMMA\|JOIN */
161783		-{ yymsp[0].minor.yy60 = JT_INNER; }
	161947	+{ yymsp[0].minor.yy376 = JT_INNER; }
161784	161948	break;
161785	161949	case 120: /* joinop ::= JOIN_KW JOIN */
161786		-{yymsp[-1].minor.yy60 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /X-overwrites-A/}
	161950	+{yymsp[-1].minor.yy376 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /X-overwrites-A/}
161787	161951	break;
161788	161952	case 121: /* joinop ::= JOIN_KW nm JOIN */
161789		-{yymsp[-2].minor.yy60 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /X-overwrites-A/}
	161953	+{yymsp[-2].minor.yy376 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /X-overwrites-A/}
161790	161954	break;
161791	161955	case 122: /* joinop ::= JOIN_KW nm nm JOIN */
161792		-{yymsp[-3].minor.yy60 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/X-overwrites-A/}
	161956	+{yymsp[-3].minor.yy376 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/X-overwrites-A/}
161793	161957	break;
161794	161958	case 123: /* on_opt ::= ON expr */
161795	161959	case 143: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==143);
161796	161960	case 150: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==150);
161797	161961	case 152: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==152);
161798	161962	case 223: /* case_else ::= ELSE expr */ yytestcase(yyruleno==223);
161799	161963	case 244: /* vinto ::= INTO expr */ yytestcase(yyruleno==244);
161800		-{yymsp[-1].minor.yy602 = yymsp[0].minor.yy602;}
	161964	+{yymsp[-1].minor.yy404 = yymsp[0].minor.yy404;}
161801	161965	break;
161802	161966	case 124: /* on_opt ::= */
161803	161967	case 142: /* having_opt ::= */ yytestcase(yyruleno==142);
161804	161968	case 144: /* limit_opt ::= */ yytestcase(yyruleno==144);
161805	161969	case 149: /* where_opt ::= */ yytestcase(yyruleno==149);
161806	161970	case 151: /* where_opt_ret ::= */ yytestcase(yyruleno==151);
161807	161971	case 224: /* case_else ::= */ yytestcase(yyruleno==224);
161808	161972	case 226: /* case_operand ::= */ yytestcase(yyruleno==226);
161809	161973	case 245: /* vinto ::= */ yytestcase(yyruleno==245);
161810		-{yymsp[1].minor.yy602 = 0;}
	161974	+{yymsp[1].minor.yy404 = 0;}
161811	161975	break;
161812	161976	case 126: /* indexed_opt ::= INDEXED BY nm */
161813	161977	{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
161814	161978	break;
161815	161979	case 127: /* indexed_opt ::= NOT INDEXED */
161816	161980	{yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
161817	161981	break;
161818	161982	case 128: /* using_opt ::= USING LP idlist RP */
161819		-{yymsp[-3].minor.yy288 = yymsp[-1].minor.yy288;}
	161983	+{yymsp[-3].minor.yy436 = yymsp[-1].minor.yy436;}
161820	161984	break;
161821	161985	case 129: /* using_opt ::= */
161822	161986	case 171: /* idlist_opt ::= */ yytestcase(yyruleno==171);
161823		-{yymsp[1].minor.yy288 = 0;}
	161987	+{yymsp[1].minor.yy436 = 0;}
161824	161988	break;
161825	161989	case 131: /* orderby_opt ::= ORDER BY sortlist */
161826	161990	case 141: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==141);
161827		-{yymsp[-2].minor.yy338 = yymsp[0].minor.yy338;}
	161991	+{yymsp[-2].minor.yy70 = yymsp[0].minor.yy70;}
161828	161992	break;
161829	161993	case 132: /* sortlist ::= sortlist COMMA expr sortorder nulls */
161830	161994	{
161831		- yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy338,yymsp[-2].minor.yy602);
161832		- sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy338,yymsp[-1].minor.yy60,yymsp[0].minor.yy60);
	161995	+ yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy70,yymsp[-2].minor.yy404);
	161996	+ sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy70,yymsp[-1].minor.yy376,yymsp[0].minor.yy376);
161833	161997	}
161834	161998	break;
161835	161999	case 133: /* sortlist ::= expr sortorder nulls */
161836	162000	{
161837		- yymsp[-2].minor.yy338 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy602); /A-overwrites-Y/
161838		- sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy338,yymsp[-1].minor.yy60,yymsp[0].minor.yy60);
	162001	+ yymsp[-2].minor.yy70 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy404); /A-overwrites-Y/
	162002	+ sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy70,yymsp[-1].minor.yy376,yymsp[0].minor.yy376);
161839	162003	}
161840	162004	break;
161841	162005	case 134: /* sortorder ::= ASC */
161842		-{yymsp[0].minor.yy60 = SQLITE_SO_ASC;}
	162006	+{yymsp[0].minor.yy376 = SQLITE_SO_ASC;}
161843	162007	break;
161844	162008	case 135: /* sortorder ::= DESC */
161845		-{yymsp[0].minor.yy60 = SQLITE_SO_DESC;}
	162009	+{yymsp[0].minor.yy376 = SQLITE_SO_DESC;}
161846	162010	break;
161847	162011	case 136: /* sortorder ::= */
161848	162012	case 139: /* nulls ::= */ yytestcase(yyruleno==139);
161849		-{yymsp[1].minor.yy60 = SQLITE_SO_UNDEFINED;}
	162013	+{yymsp[1].minor.yy376 = SQLITE_SO_UNDEFINED;}
161850	162014	break;
161851	162015	case 137: /* nulls ::= NULLS FIRST */
161852		-{yymsp[-1].minor.yy60 = SQLITE_SO_ASC;}
	162016	+{yymsp[-1].minor.yy376 = SQLITE_SO_ASC;}
161853	162017	break;
161854	162018	case 138: /* nulls ::= NULLS LAST */
161855		-{yymsp[-1].minor.yy60 = SQLITE_SO_DESC;}
	162019	+{yymsp[-1].minor.yy376 = SQLITE_SO_DESC;}
161856	162020	break;
161857	162021	case 145: /* limit_opt ::= LIMIT expr */
161858		-{yymsp[-1].minor.yy602 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy602,0);}
	162022	+{yymsp[-1].minor.yy404 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy404,0);}
161859	162023	break;
161860	162024	case 146: /* limit_opt ::= LIMIT expr OFFSET expr */
161861		-{yymsp[-3].minor.yy602 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy602,yymsp[0].minor.yy602);}
	162025	+{yymsp[-3].minor.yy404 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy404,yymsp[0].minor.yy404);}
161862	162026	break;
161863	162027	case 147: /* limit_opt ::= LIMIT expr COMMA expr */
161864		-{yymsp[-3].minor.yy602 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy602,yymsp[-2].minor.yy602);}
	162028	+{yymsp[-3].minor.yy404 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy404,yymsp[-2].minor.yy404);}
161865	162029	break;
161866	162030	case 148: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
161867	162031	{
161868		- sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy291, &yymsp[-1].minor.yy0);
161869		- sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy291,yymsp[0].minor.yy602,0,0);
	162032	+ sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy153, &yymsp[-1].minor.yy0);
	162033	+ sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy153,yymsp[0].minor.yy404,0,0);
161870	162034	}
161871	162035	break;
161872	162036	case 153: /* where_opt_ret ::= RETURNING selcollist */
161873		-{sqlite3AddReturning(pParse,yymsp[0].minor.yy338); yymsp[-1].minor.yy602 = 0;}
	162037	+{sqlite3AddReturning(pParse,yymsp[0].minor.yy70); yymsp[-1].minor.yy404 = 0;}
161874	162038	break;
161875	162039	case 154: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
161876		-{sqlite3AddReturning(pParse,yymsp[0].minor.yy338); yymsp[-3].minor.yy602 = yymsp[-2].minor.yy602;}
	162040	+{sqlite3AddReturning(pParse,yymsp[0].minor.yy70); yymsp[-3].minor.yy404 = yymsp[-2].minor.yy404;}
161877	162041	break;
161878	162042	case 155: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
161879	162043	{
161880		- sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy291, &yymsp[-4].minor.yy0);
161881		- sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy338,"set list");
161882		- yymsp[-5].minor.yy291 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy291, yymsp[-1].minor.yy291);
161883		- sqlite3Update(pParse,yymsp[-5].minor.yy291,yymsp[-2].minor.yy338,yymsp[0].minor.yy602,yymsp[-6].minor.yy60,0,0,0);
	162044	+ sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy153, &yymsp[-4].minor.yy0);
	162045	+ sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy70,"set list");
	162046	+ yymsp[-5].minor.yy153 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy153, yymsp[-1].minor.yy153);
	162047	+ sqlite3Update(pParse,yymsp[-5].minor.yy153,yymsp[-2].minor.yy70,yymsp[0].minor.yy404,yymsp[-6].minor.yy376,0,0,0);
161884	162048	}
161885	162049	break;
161886	162050	case 156: /* setlist ::= setlist COMMA nm EQ expr */
161887	162051	{
161888		- yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy338, yymsp[0].minor.yy602);
161889		- sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy338, &yymsp[-2].minor.yy0, 1);
	162052	+ yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy70, yymsp[0].minor.yy404);
	162053	+ sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy70, &yymsp[-2].minor.yy0, 1);
161890	162054	}
161891	162055	break;
161892	162056	case 157: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
161893	162057	{
161894		- yymsp[-6].minor.yy338 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy338, yymsp[-3].minor.yy288, yymsp[0].minor.yy602);
	162058	+ yymsp[-6].minor.yy70 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy70, yymsp[-3].minor.yy436, yymsp[0].minor.yy404);
161895	162059	}
161896	162060	break;
161897	162061	case 158: /* setlist ::= nm EQ expr */
161898	162062	{
161899		- yylhsminor.yy338 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy602);
161900		- sqlite3ExprListSetName(pParse, yylhsminor.yy338, &yymsp[-2].minor.yy0, 1);
	162063	+ yylhsminor.yy70 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy404);
	162064	+ sqlite3ExprListSetName(pParse, yylhsminor.yy70, &yymsp[-2].minor.yy0, 1);
161901	162065	}
161902		- yymsp[-2].minor.yy338 = yylhsminor.yy338;
	162066	+ yymsp[-2].minor.yy70 = yylhsminor.yy70;
161903	162067	break;
161904	162068	case 159: /* setlist ::= LP idlist RP EQ expr */
161905	162069	{
161906		- yymsp[-4].minor.yy338 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy288, yymsp[0].minor.yy602);
	162070	+ yymsp[-4].minor.yy70 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy436, yymsp[0].minor.yy404);
161907	162071	}
161908	162072	break;
161909	162073	case 160: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
161910	162074	{
161911		- sqlite3Insert(pParse, yymsp[-3].minor.yy291, yymsp[-1].minor.yy307, yymsp[-2].minor.yy288, yymsp[-5].minor.yy60, yymsp[0].minor.yy178);
	162075	+ sqlite3Insert(pParse, yymsp[-3].minor.yy153, yymsp[-1].minor.yy81, yymsp[-2].minor.yy436, yymsp[-5].minor.yy376, yymsp[0].minor.yy190);
161912	162076	}
161913	162077	break;
161914	162078	case 161: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
161915	162079	{
161916		- sqlite3Insert(pParse, yymsp[-4].minor.yy291, 0, yymsp[-3].minor.yy288, yymsp[-6].minor.yy60, 0);
	162080	+ sqlite3Insert(pParse, yymsp[-4].minor.yy153, 0, yymsp[-3].minor.yy436, yymsp[-6].minor.yy376, 0);
161917	162081	}
161918	162082	break;
161919	162083	case 162: /* upsert ::= */
161920		-{ yymsp[1].minor.yy178 = 0; }
	162084	+{ yymsp[1].minor.yy190 = 0; }
161921	162085	break;
161922	162086	case 163: /* upsert ::= RETURNING selcollist */
161923		-{ yymsp[-1].minor.yy178 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy338); }
	162087	+{ yymsp[-1].minor.yy190 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy70); }
161924	162088	break;
161925	162089	case 164: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
161926		-{ yymsp[-11].minor.yy178 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy338,yymsp[-6].minor.yy602,yymsp[-2].minor.yy338,yymsp[-1].minor.yy602,yymsp[0].minor.yy178);}
	162090	+{ yymsp[-11].minor.yy190 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy70,yymsp[-6].minor.yy404,yymsp[-2].minor.yy70,yymsp[-1].minor.yy404,yymsp[0].minor.yy190);}
161927	162091	break;
161928	162092	case 165: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
161929		-{ yymsp[-8].minor.yy178 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy338,yymsp[-3].minor.yy602,0,0,yymsp[0].minor.yy178); }
	162093	+{ yymsp[-8].minor.yy190 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy70,yymsp[-3].minor.yy404,0,0,yymsp[0].minor.yy190); }
161930	162094	break;
161931	162095	case 166: /* upsert ::= ON CONFLICT DO NOTHING returning */
161932		-{ yymsp[-4].minor.yy178 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
	162096	+{ yymsp[-4].minor.yy190 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
161933	162097	break;
161934	162098	case 167: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
161935		-{ yymsp[-7].minor.yy178 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy338,yymsp[-1].minor.yy602,0);}
	162099	+{ yymsp[-7].minor.yy190 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy70,yymsp[-1].minor.yy404,0);}
161936	162100	break;
161937	162101	case 168: /* returning ::= RETURNING selcollist */
161938		-{sqlite3AddReturning(pParse,yymsp[0].minor.yy338);}
	162102	+{sqlite3AddReturning(pParse,yymsp[0].minor.yy70);}
161939	162103	break;
161940	162104	case 172: /* idlist_opt ::= LP idlist RP */
161941		-{yymsp[-2].minor.yy288 = yymsp[-1].minor.yy288;}
	162105	+{yymsp[-2].minor.yy436 = yymsp[-1].minor.yy436;}
161942	162106	break;
161943	162107	case 173: /* idlist ::= idlist COMMA nm */
161944		-{yymsp[-2].minor.yy288 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy288,&yymsp[0].minor.yy0);}
	162108	+{yymsp[-2].minor.yy436 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy436,&yymsp[0].minor.yy0);}
161945	162109	break;
161946	162110	case 174: /* idlist ::= nm */
161947		-{yymsp[0].minor.yy288 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /A-overwrites-Y/}
	162111	+{yymsp[0].minor.yy436 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /A-overwrites-Y/}
161948	162112	break;
161949	162113	case 175: /* expr ::= LP expr RP */
161950		-{yymsp[-2].minor.yy602 = yymsp[-1].minor.yy602;}
	162114	+{yymsp[-2].minor.yy404 = yymsp[-1].minor.yy404;}
161951	162115	break;
161952	162116	case 176: /* expr ::= ID\|INDEXED */
161953	162117	case 177: /* expr ::= JOIN_KW */ yytestcase(yyruleno==177);
161954		-{yymsp[0].minor.yy602=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /A-overwrites-X/}
	162118	+{yymsp[0].minor.yy404=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /A-overwrites-X/}
161955	162119	break;
161956	162120	case 178: /* expr ::= nm DOT nm */
161957	162121	{
161958	162122	Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
161959	162123	Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1);
161960	162124	if( IN_RENAME_OBJECT ){
161961	162125	sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0);
161962	162126	sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0);
161963	162127	}
161964		- yylhsminor.yy602 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
	162128	+ yylhsminor.yy404 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
161965	162129	}
161966		- yymsp[-2].minor.yy602 = yylhsminor.yy602;
	162130	+ yymsp[-2].minor.yy404 = yylhsminor.yy404;
161967	162131	break;
161968	162132	case 179: /* expr ::= nm DOT nm DOT nm */
161969	162133	{
161970	162134	Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-4].minor.yy0, 1);
161971	162135	Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
		@@ -161973,322 +162137,322 @@
161973	162137	Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
161974	162138	if( IN_RENAME_OBJECT ){
161975	162139	sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0);
161976	162140	sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0);
161977	162141	}
161978		- yylhsminor.yy602 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
	162142	+ yylhsminor.yy404 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
161979	162143	}
161980		- yymsp[-4].minor.yy602 = yylhsminor.yy602;
	162144	+ yymsp[-4].minor.yy404 = yylhsminor.yy404;
161981	162145	break;
161982	162146	case 180: /* term ::= NULL\|FLOAT\|BLOB */
161983	162147	case 181: /* term ::= STRING */ yytestcase(yyruleno==181);
161984		-{yymsp[0].minor.yy602=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /A-overwrites-X/}
	162148	+{yymsp[0].minor.yy404=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /A-overwrites-X/}
161985	162149	break;
161986	162150	case 182: /* term ::= INTEGER */
161987	162151	{
161988		- yylhsminor.yy602 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
	162152	+ yylhsminor.yy404 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
161989	162153	}
161990		- yymsp[0].minor.yy602 = yylhsminor.yy602;
	162154	+ yymsp[0].minor.yy404 = yylhsminor.yy404;
161991	162155	break;
161992	162156	case 183: /* expr ::= VARIABLE */
161993	162157	{
161994	162158	if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
161995	162159	u32 n = yymsp[0].minor.yy0.n;
161996		- yymsp[0].minor.yy602 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
161997		- sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy602, n);
	162160	+ yymsp[0].minor.yy404 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
	162161	+ sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy404, n);
161998	162162	}else{
161999	162163	/* When doing a nested parse, one can include terms in an expression
162000	162164	** that look like this: #1 #2 ... These terms refer to registers
162001	162165	** in the virtual machine. #N is the N-th register. */
162002	162166	Token t = yymsp[0].minor.yy0; /A-overwrites-X/
162003	162167	assert( t.n>=2 );
162004	162168	if( pParse->nested==0 ){
162005	162169	sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
162006		- yymsp[0].minor.yy602 = 0;
	162170	+ yymsp[0].minor.yy404 = 0;
162007	162171	}else{
162008		- yymsp[0].minor.yy602 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
162009		- if( yymsp[0].minor.yy602 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy602->iTable);
	162172	+ yymsp[0].minor.yy404 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
	162173	+ if( yymsp[0].minor.yy404 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy404->iTable);
162010	162174	}
162011	162175	}
162012	162176	}
162013	162177	break;
162014	162178	case 184: /* expr ::= expr COLLATE ID\|STRING */
162015	162179	{
162016		- yymsp[-2].minor.yy602 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy602, &yymsp[0].minor.yy0, 1);
	162180	+ yymsp[-2].minor.yy404 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy404, &yymsp[0].minor.yy0, 1);
162017	162181	}
162018	162182	break;
162019	162183	case 185: /* expr ::= CAST LP expr AS typetoken RP */
162020	162184	{
162021		- yymsp[-5].minor.yy602 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
162022		- sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy602, yymsp[-3].minor.yy602, 0);
	162185	+ yymsp[-5].minor.yy404 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
	162186	+ sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy404, yymsp[-3].minor.yy404, 0);
162023	162187	}
162024	162188	break;
162025	162189	case 186: /* expr ::= ID\|INDEXED LP distinct exprlist RP */
162026	162190	{
162027		- yylhsminor.yy602 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy338, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy60);
	162191	+ yylhsminor.yy404 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy70, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy376);
162028	162192	}
162029		- yymsp[-4].minor.yy602 = yylhsminor.yy602;
	162193	+ yymsp[-4].minor.yy404 = yylhsminor.yy404;
162030	162194	break;
162031	162195	case 187: /* expr ::= ID\|INDEXED LP STAR RP */
162032	162196	{
162033		- yylhsminor.yy602 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
	162197	+ yylhsminor.yy404 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
162034	162198	}
162035		- yymsp[-3].minor.yy602 = yylhsminor.yy602;
	162199	+ yymsp[-3].minor.yy404 = yylhsminor.yy404;
162036	162200	break;
162037	162201	case 188: /* expr ::= ID\|INDEXED LP distinct exprlist RP filter_over */
162038	162202	{
162039		- yylhsminor.yy602 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy338, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy60);
162040		- sqlite3WindowAttach(pParse, yylhsminor.yy602, yymsp[0].minor.yy19);
	162203	+ yylhsminor.yy404 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy70, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy376);
	162204	+ sqlite3WindowAttach(pParse, yylhsminor.yy404, yymsp[0].minor.yy49);
162041	162205	}
162042		- yymsp[-5].minor.yy602 = yylhsminor.yy602;
	162206	+ yymsp[-5].minor.yy404 = yylhsminor.yy404;
162043	162207	break;
162044	162208	case 189: /* expr ::= ID\|INDEXED LP STAR RP filter_over */
162045	162209	{
162046		- yylhsminor.yy602 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
162047		- sqlite3WindowAttach(pParse, yylhsminor.yy602, yymsp[0].minor.yy19);
	162210	+ yylhsminor.yy404 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
	162211	+ sqlite3WindowAttach(pParse, yylhsminor.yy404, yymsp[0].minor.yy49);
162048	162212	}
162049		- yymsp[-4].minor.yy602 = yylhsminor.yy602;
	162213	+ yymsp[-4].minor.yy404 = yylhsminor.yy404;
162050	162214	break;
162051	162215	case 190: /* term ::= CTIME_KW */
162052	162216	{
162053		- yylhsminor.yy602 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
	162217	+ yylhsminor.yy404 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
162054	162218	}
162055		- yymsp[0].minor.yy602 = yylhsminor.yy602;
	162219	+ yymsp[0].minor.yy404 = yylhsminor.yy404;
162056	162220	break;
162057	162221	case 191: /* expr ::= LP nexprlist COMMA expr RP */
162058	162222	{
162059		- ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy338, yymsp[-1].minor.yy602);
162060		- yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
162061		- if( yymsp[-4].minor.yy602 ){
162062		- yymsp[-4].minor.yy602->x.pList = pList;
	162223	+ ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy70, yymsp[-1].minor.yy404);
	162224	+ yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
	162225	+ if( yymsp[-4].minor.yy404 ){
	162226	+ yymsp[-4].minor.yy404->x.pList = pList;
162063	162227	if( ALWAYS(pList->nExpr) ){
162064		- yymsp[-4].minor.yy602->flags \|= pList->a[0].pExpr->flags & EP_Propagate;
	162228	+ yymsp[-4].minor.yy404->flags \|= pList->a[0].pExpr->flags & EP_Propagate;
162065	162229	}
162066	162230	}else{
162067	162231	sqlite3ExprListDelete(pParse->db, pList);
162068	162232	}
162069	162233	}
162070	162234	break;
162071	162235	case 192: /* expr ::= expr AND expr */
162072		-{yymsp[-2].minor.yy602=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy602,yymsp[0].minor.yy602);}
	162236	+{yymsp[-2].minor.yy404=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy404,yymsp[0].minor.yy404);}
162073	162237	break;
162074	162238	case 193: /* expr ::= expr OR expr */
162075	162239	case 194: /* expr ::= expr LT\|GT\|GE\|LE expr */ yytestcase(yyruleno==194);
162076	162240	case 195: /* expr ::= expr EQ\|NE expr */ yytestcase(yyruleno==195);
162077	162241	case 196: /* expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */ yytestcase(yyruleno==196);
162078	162242	case 197: /* expr ::= expr PLUS\|MINUS expr */ yytestcase(yyruleno==197);
162079	162243	case 198: /* expr ::= expr STAR\|SLASH\|REM expr */ yytestcase(yyruleno==198);
162080	162244	case 199: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==199);
162081		-{yymsp[-2].minor.yy602=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy602,yymsp[0].minor.yy602);}
	162245	+{yymsp[-2].minor.yy404=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy404,yymsp[0].minor.yy404);}
162082	162246	break;
162083	162247	case 200: /* likeop ::= NOT LIKE_KW\|MATCH */
162084	162248	{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n\|=0x80000000; /yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0/}
162085	162249	break;
162086	162250	case 201: /* expr ::= expr likeop expr */
162087	162251	{
162088	162252	ExprList *pList;
162089	162253	int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
162090	162254	yymsp[-1].minor.yy0.n &= 0x7fffffff;
162091		- pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy602);
162092		- pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy602);
162093		- yymsp[-2].minor.yy602 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
162094		- if( bNot ) yymsp[-2].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy602, 0);
162095		- if( yymsp[-2].minor.yy602 ) yymsp[-2].minor.yy602->flags \|= EP_InfixFunc;
	162255	+ pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy404);
	162256	+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy404);
	162257	+ yymsp[-2].minor.yy404 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
	162258	+ if( bNot ) yymsp[-2].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy404, 0);
	162259	+ if( yymsp[-2].minor.yy404 ) yymsp[-2].minor.yy404->flags \|= EP_InfixFunc;
162096	162260	}
162097	162261	break;
162098	162262	case 202: /* expr ::= expr likeop expr ESCAPE expr */
162099	162263	{
162100	162264	ExprList *pList;
162101	162265	int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
162102	162266	yymsp[-3].minor.yy0.n &= 0x7fffffff;
162103		- pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy602);
162104		- pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy602);
162105		- pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy602);
162106		- yymsp[-4].minor.yy602 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
162107		- if( bNot ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
162108		- if( yymsp[-4].minor.yy602 ) yymsp[-4].minor.yy602->flags \|= EP_InfixFunc;
	162267	+ pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy404);
	162268	+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy404);
	162269	+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy404);
	162270	+ yymsp[-4].minor.yy404 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
	162271	+ if( bNot ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
	162272	+ if( yymsp[-4].minor.yy404 ) yymsp[-4].minor.yy404->flags \|= EP_InfixFunc;
162109	162273	}
162110	162274	break;
162111	162275	case 203: /* expr ::= expr ISNULL\|NOTNULL */
162112		-{yymsp[-1].minor.yy602 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy602,0);}
	162276	+{yymsp[-1].minor.yy404 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy404,0);}
162113	162277	break;
162114	162278	case 204: /* expr ::= expr NOT NULL */
162115		-{yymsp[-2].minor.yy602 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy602,0);}
	162279	+{yymsp[-2].minor.yy404 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy404,0);}
162116	162280	break;
162117	162281	case 205: /* expr ::= expr IS expr */
162118	162282	{
162119		- yymsp[-2].minor.yy602 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy602,yymsp[0].minor.yy602);
162120		- binaryToUnaryIfNull(pParse, yymsp[0].minor.yy602, yymsp[-2].minor.yy602, TK_ISNULL);
	162283	+ yymsp[-2].minor.yy404 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy404,yymsp[0].minor.yy404);
	162284	+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy404, yymsp[-2].minor.yy404, TK_ISNULL);
162121	162285	}
162122	162286	break;
162123	162287	case 206: /* expr ::= expr IS NOT expr */
162124	162288	{
162125		- yymsp[-3].minor.yy602 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy602,yymsp[0].minor.yy602);
162126		- binaryToUnaryIfNull(pParse, yymsp[0].minor.yy602, yymsp[-3].minor.yy602, TK_NOTNULL);
	162289	+ yymsp[-3].minor.yy404 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy404,yymsp[0].minor.yy404);
	162290	+ binaryToUnaryIfNull(pParse, yymsp[0].minor.yy404, yymsp[-3].minor.yy404, TK_NOTNULL);
162127	162291	}
162128	162292	break;
162129	162293	case 207: /* expr ::= NOT expr */
162130	162294	case 208: /* expr ::= BITNOT expr */ yytestcase(yyruleno==208);
162131		-{yymsp[-1].minor.yy602 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy602, 0);/A-overwrites-B/}
	162295	+{yymsp[-1].minor.yy404 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy404, 0);/A-overwrites-B/}
162132	162296	break;
162133	162297	case 209: /* expr ::= PLUS\|MINUS expr */
162134	162298	{
162135		- yymsp[-1].minor.yy602 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy602, 0);
	162299	+ yymsp[-1].minor.yy404 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy404, 0);
162136	162300	/A-overwrites-B/
162137	162301	}
162138	162302	break;
162139	162303	case 210: /* between_op ::= BETWEEN */
162140	162304	case 213: /* in_op ::= IN */ yytestcase(yyruleno==213);
162141		-{yymsp[0].minor.yy60 = 0;}
	162305	+{yymsp[0].minor.yy376 = 0;}
162142	162306	break;
162143	162307	case 212: /* expr ::= expr between_op expr AND expr */
162144	162308	{
162145		- ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy602);
162146		- pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy602);
162147		- yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy602, 0);
162148		- if( yymsp[-4].minor.yy602 ){
162149		- yymsp[-4].minor.yy602->x.pList = pList;
	162309	+ ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy404);
	162310	+ pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy404);
	162311	+ yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy404, 0);
	162312	+ if( yymsp[-4].minor.yy404 ){
	162313	+ yymsp[-4].minor.yy404->x.pList = pList;
162150	162314	}else{
162151	162315	sqlite3ExprListDelete(pParse->db, pList);
162152	162316	}
162153		- if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
	162317	+ if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162154	162318	}
162155	162319	break;
162156	162320	case 215: /* expr ::= expr in_op LP exprlist RP */
162157	162321	{
162158		- if( yymsp[-1].minor.yy338==0 ){
	162322	+ if( yymsp[-1].minor.yy70==0 ){
162159	162323	/* Expressions of the form
162160	162324	**
162161	162325	** expr1 IN ()
162162	162326	** expr1 NOT IN ()
162163	162327	**
162164	162328	** simplify to constants 0 (false) and 1 (true), respectively,
162165	162329	** regardless of the value of expr1.
162166	162330	*/
162167		- sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy602);
162168		- yymsp[-4].minor.yy602 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy60 ? "1" : "0");
162169		- }else if( yymsp[-1].minor.yy338->nExpr==1 && sqlite3ExprIsConstant(yymsp[-1].minor.yy338->a[0].pExpr) ){
162170		- Expr *pRHS = yymsp[-1].minor.yy338->a[0].pExpr;
162171		- yymsp[-1].minor.yy338->a[0].pExpr = 0;
162172		- sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy338);
	162331	+ sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy404);
	162332	+ yymsp[-4].minor.yy404 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy376 ? "1" : "0");
	162333	+ }else if( yymsp[-1].minor.yy70->nExpr==1 && sqlite3ExprIsConstant(yymsp[-1].minor.yy70->a[0].pExpr) ){
	162334	+ Expr *pRHS = yymsp[-1].minor.yy70->a[0].pExpr;
	162335	+ yymsp[-1].minor.yy70->a[0].pExpr = 0;
	162336	+ sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy70);
162173	162337	pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
162174		- yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy602, pRHS);
162175		- if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
162176		- }else{
162177		- yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy602, 0);
162178		- if( yymsp[-4].minor.yy602 ){
162179		- yymsp[-4].minor.yy602->x.pList = yymsp[-1].minor.yy338;
162180		- sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy602);
162181		- }else{
162182		- sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy338);
162183		- }
162184		- if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
	162338	+ yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy404, pRHS);
	162339	+ if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
	162340	+ }else{
	162341	+ yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy404, 0);
	162342	+ if( yymsp[-4].minor.yy404 ){
	162343	+ yymsp[-4].minor.yy404->x.pList = yymsp[-1].minor.yy70;
	162344	+ sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy404);
	162345	+ }else{
	162346	+ sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy70);
	162347	+ }
	162348	+ if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162185	162349	}
162186	162350	}
162187	162351	break;
162188	162352	case 216: /* expr ::= LP select RP */
162189	162353	{
162190		- yymsp[-2].minor.yy602 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
162191		- sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy602, yymsp[-1].minor.yy307);
	162354	+ yymsp[-2].minor.yy404 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
	162355	+ sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy404, yymsp[-1].minor.yy81);
162192	162356	}
162193	162357	break;
162194	162358	case 217: /* expr ::= expr in_op LP select RP */
162195	162359	{
162196		- yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy602, 0);
162197		- sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy602, yymsp[-1].minor.yy307);
162198		- if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
	162360	+ yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy404, 0);
	162361	+ sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy404, yymsp[-1].minor.yy81);
	162362	+ if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162199	162363	}
162200	162364	break;
162201	162365	case 218: /* expr ::= expr in_op nm dbnm paren_exprlist */
162202	162366	{
162203	162367	SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
162204	162368	Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
162205		- if( yymsp[0].minor.yy338 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy338);
162206		- yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy602, 0);
162207		- sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy602, pSelect);
162208		- if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
	162369	+ if( yymsp[0].minor.yy70 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy70);
	162370	+ yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy404, 0);
	162371	+ sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy404, pSelect);
	162372	+ if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162209	162373	}
162210	162374	break;
162211	162375	case 219: /* expr ::= EXISTS LP select RP */
162212	162376	{
162213	162377	Expr *p;
162214		- p = yymsp[-3].minor.yy602 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
162215		- sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy307);
	162378	+ p = yymsp[-3].minor.yy404 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
	162379	+ sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy81);
162216	162380	}
162217	162381	break;
162218	162382	case 220: /* expr ::= CASE case_operand case_exprlist case_else END */
162219	162383	{
162220		- yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy602, 0);
162221		- if( yymsp[-4].minor.yy602 ){
162222		- yymsp[-4].minor.yy602->x.pList = yymsp[-1].minor.yy602 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy338,yymsp[-1].minor.yy602) : yymsp[-2].minor.yy338;
162223		- sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy602);
	162384	+ yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy404, 0);
	162385	+ if( yymsp[-4].minor.yy404 ){
	162386	+ yymsp[-4].minor.yy404->x.pList = yymsp[-1].minor.yy404 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy70,yymsp[-1].minor.yy404) : yymsp[-2].minor.yy70;
	162387	+ sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy404);
162224	162388	}else{
162225		- sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy338);
162226		- sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy602);
	162389	+ sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy70);
	162390	+ sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy404);
162227	162391	}
162228	162392	}
162229	162393	break;
162230	162394	case 221: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
162231	162395	{
162232		- yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy338, yymsp[-2].minor.yy602);
162233		- yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy338, yymsp[0].minor.yy602);
	162396	+ yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy70, yymsp[-2].minor.yy404);
	162397	+ yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy70, yymsp[0].minor.yy404);
162234	162398	}
162235	162399	break;
162236	162400	case 222: /* case_exprlist ::= WHEN expr THEN expr */
162237	162401	{
162238		- yymsp[-3].minor.yy338 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy602);
162239		- yymsp[-3].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy338, yymsp[0].minor.yy602);
	162402	+ yymsp[-3].minor.yy70 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy404);
	162403	+ yymsp[-3].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy70, yymsp[0].minor.yy404);
162240	162404	}
162241	162405	break;
162242	162406	case 225: /* case_operand ::= expr */
162243		-{yymsp[0].minor.yy602 = yymsp[0].minor.yy602; /A-overwrites-X/}
	162407	+{yymsp[0].minor.yy404 = yymsp[0].minor.yy404; /A-overwrites-X/}
162244	162408	break;
162245	162409	case 228: /* nexprlist ::= nexprlist COMMA expr */
162246		-{yymsp[-2].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy338,yymsp[0].minor.yy602);}
	162410	+{yymsp[-2].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy70,yymsp[0].minor.yy404);}
162247	162411	break;
162248	162412	case 229: /* nexprlist ::= expr */
162249		-{yymsp[0].minor.yy338 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy602); /A-overwrites-Y/}
	162413	+{yymsp[0].minor.yy70 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy404); /A-overwrites-Y/}
162250	162414	break;
162251	162415	case 231: /* paren_exprlist ::= LP exprlist RP */
162252	162416	case 236: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==236);
162253		-{yymsp[-2].minor.yy338 = yymsp[-1].minor.yy338;}
	162417	+{yymsp[-2].minor.yy70 = yymsp[-1].minor.yy70;}
162254	162418	break;
162255	162419	case 232: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
162256	162420	{
162257	162421	sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
162258		- sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy338, yymsp[-10].minor.yy60,
162259		- &yymsp[-11].minor.yy0, yymsp[0].minor.yy602, SQLITE_SO_ASC, yymsp[-8].minor.yy60, SQLITE_IDXTYPE_APPDEF);
	162422	+ sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy70, yymsp[-10].minor.yy376,
	162423	+ &yymsp[-11].minor.yy0, yymsp[0].minor.yy404, SQLITE_SO_ASC, yymsp[-8].minor.yy376, SQLITE_IDXTYPE_APPDEF);
162260	162424	if( IN_RENAME_OBJECT && pParse->pNewIndex ){
162261	162425	sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
162262	162426	}
162263	162427	}
162264	162428	break;
162265	162429	case 233: /* uniqueflag ::= UNIQUE */
162266	162430	case 275: /* raisetype ::= ABORT */ yytestcase(yyruleno==275);
162267		-{yymsp[0].minor.yy60 = OE_Abort;}
	162431	+{yymsp[0].minor.yy376 = OE_Abort;}
162268	162432	break;
162269	162433	case 234: /* uniqueflag ::= */
162270		-{yymsp[1].minor.yy60 = OE_None;}
	162434	+{yymsp[1].minor.yy376 = OE_None;}
162271	162435	break;
162272	162436	case 237: /* eidlist ::= eidlist COMMA nm collate sortorder */
162273	162437	{
162274		- yymsp[-4].minor.yy338 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy338, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy60, yymsp[0].minor.yy60);
	162438	+ yymsp[-4].minor.yy70 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy70, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy376, yymsp[0].minor.yy376);
162275	162439	}
162276	162440	break;
162277	162441	case 238: /* eidlist ::= nm collate sortorder */
162278	162442	{
162279		- yymsp[-2].minor.yy338 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy60, yymsp[0].minor.yy60); /A-overwrites-Y/
	162443	+ yymsp[-2].minor.yy70 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy376, yymsp[0].minor.yy376); /A-overwrites-Y/
162280	162444	}
162281	162445	break;
162282	162446	case 241: /* cmd ::= DROP INDEX ifexists fullname */
162283		-{sqlite3DropIndex(pParse, yymsp[0].minor.yy291, yymsp[-1].minor.yy60);}
	162447	+{sqlite3DropIndex(pParse, yymsp[0].minor.yy153, yymsp[-1].minor.yy376);}
162284	162448	break;
162285	162449	case 242: /* cmd ::= VACUUM vinto */
162286		-{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy602);}
	162450	+{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy404);}
162287	162451	break;
162288	162452	case 243: /* cmd ::= VACUUM nm vinto */
162289		-{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy602);}
	162453	+{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy404);}
162290	162454	break;
162291	162455	case 246: /* cmd ::= PRAGMA nm dbnm */
162292	162456	{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
162293	162457	break;
162294	162458	case 247: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
		@@ -162306,54 +162470,54 @@
162306	162470	case 253: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
162307	162471	{
162308	162472	Token all;
162309	162473	all.z = yymsp[-3].minor.yy0.z;
162310	162474	all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
162311		- sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy483, &all);
	162475	+ sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy157, &all);
162312	162476	}
162313	162477	break;
162314	162478	case 254: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
162315	162479	{
162316		- sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy60, yymsp[-4].minor.yy50.a, yymsp[-4].minor.yy50.b, yymsp[-2].minor.yy291, yymsp[0].minor.yy602, yymsp[-10].minor.yy60, yymsp[-8].minor.yy60);
	162480	+ sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy376, yymsp[-4].minor.yy262.a, yymsp[-4].minor.yy262.b, yymsp[-2].minor.yy153, yymsp[0].minor.yy404, yymsp[-10].minor.yy376, yymsp[-8].minor.yy376);
162317	162481	yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /A-overwrites-T/
162318	162482	}
162319	162483	break;
162320	162484	case 255: /* trigger_time ::= BEFORE\|AFTER */
162321		-{ yymsp[0].minor.yy60 = yymsp[0].major; /A-overwrites-X/ }
	162485	+{ yymsp[0].minor.yy376 = yymsp[0].major; /A-overwrites-X/ }
162322	162486	break;
162323	162487	case 256: /* trigger_time ::= INSTEAD OF */
162324		-{ yymsp[-1].minor.yy60 = TK_INSTEAD;}
	162488	+{ yymsp[-1].minor.yy376 = TK_INSTEAD;}
162325	162489	break;
162326	162490	case 257: /* trigger_time ::= */
162327		-{ yymsp[1].minor.yy60 = TK_BEFORE; }
	162491	+{ yymsp[1].minor.yy376 = TK_BEFORE; }
162328	162492	break;
162329	162493	case 258: /* trigger_event ::= DELETE\|INSERT */
162330	162494	case 259: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==259);
162331		-{yymsp[0].minor.yy50.a = yymsp[0].major; /A-overwrites-X/ yymsp[0].minor.yy50.b = 0;}
	162495	+{yymsp[0].minor.yy262.a = yymsp[0].major; /A-overwrites-X/ yymsp[0].minor.yy262.b = 0;}
162332	162496	break;
162333	162497	case 260: /* trigger_event ::= UPDATE OF idlist */
162334		-{yymsp[-2].minor.yy50.a = TK_UPDATE; yymsp[-2].minor.yy50.b = yymsp[0].minor.yy288;}
	162498	+{yymsp[-2].minor.yy262.a = TK_UPDATE; yymsp[-2].minor.yy262.b = yymsp[0].minor.yy436;}
162335	162499	break;
162336	162500	case 261: /* when_clause ::= */
162337	162501	case 280: /* key_opt ::= */ yytestcase(yyruleno==280);
162338		-{ yymsp[1].minor.yy602 = 0; }
	162502	+{ yymsp[1].minor.yy404 = 0; }
162339	162503	break;
162340	162504	case 262: /* when_clause ::= WHEN expr */
162341	162505	case 281: /* key_opt ::= KEY expr */ yytestcase(yyruleno==281);
162342		-{ yymsp[-1].minor.yy602 = yymsp[0].minor.yy602; }
	162506	+{ yymsp[-1].minor.yy404 = yymsp[0].minor.yy404; }
162343	162507	break;
162344	162508	case 263: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
162345	162509	{
162346		- assert( yymsp[-2].minor.yy483!=0 );
162347		- yymsp[-2].minor.yy483->pLast->pNext = yymsp[-1].minor.yy483;
162348		- yymsp[-2].minor.yy483->pLast = yymsp[-1].minor.yy483;
	162510	+ assert( yymsp[-2].minor.yy157!=0 );
	162511	+ yymsp[-2].minor.yy157->pLast->pNext = yymsp[-1].minor.yy157;
	162512	+ yymsp[-2].minor.yy157->pLast = yymsp[-1].minor.yy157;
162349	162513	}
162350	162514	break;
162351	162515	case 264: /* trigger_cmd_list ::= trigger_cmd SEMI */
162352	162516	{
162353		- assert( yymsp[-1].minor.yy483!=0 );
162354		- yymsp[-1].minor.yy483->pLast = yymsp[-1].minor.yy483;
	162517	+ assert( yymsp[-1].minor.yy157!=0 );
	162518	+ yymsp[-1].minor.yy157->pLast = yymsp[-1].minor.yy157;
162355	162519	}
162356	162520	break;
162357	162521	case 265: /* trnm ::= nm DOT nm */
162358	162522	{
162359	162523	yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
		@@ -162375,62 +162539,62 @@
162375	162539	"the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
162376	162540	"within triggers");
162377	162541	}
162378	162542	break;
162379	162543	case 268: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
162380		-{yylhsminor.yy483 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy291, yymsp[-3].minor.yy338, yymsp[-1].minor.yy602, yymsp[-7].minor.yy60, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy528);}
162381		- yymsp[-8].minor.yy483 = yylhsminor.yy483;
	162544	+{yylhsminor.yy157 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy153, yymsp[-3].minor.yy70, yymsp[-1].minor.yy404, yymsp[-7].minor.yy376, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy504);}
	162545	+ yymsp[-8].minor.yy157 = yylhsminor.yy157;
162382	162546	break;
162383	162547	case 269: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
162384	162548	{
162385		- yylhsminor.yy483 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy288,yymsp[-2].minor.yy307,yymsp[-6].minor.yy60,yymsp[-1].minor.yy178,yymsp[-7].minor.yy528,yymsp[0].minor.yy528);/yylhsminor.yy483-overwrites-yymsp[-6].minor.yy60/
	162549	+ yylhsminor.yy157 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy436,yymsp[-2].minor.yy81,yymsp[-6].minor.yy376,yymsp[-1].minor.yy190,yymsp[-7].minor.yy504,yymsp[0].minor.yy504);/yylhsminor.yy157-overwrites-yymsp[-6].minor.yy376/
162386	162550	}
162387		- yymsp[-7].minor.yy483 = yylhsminor.yy483;
	162551	+ yymsp[-7].minor.yy157 = yylhsminor.yy157;
162388	162552	break;
162389	162553	case 270: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
162390		-{yylhsminor.yy483 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy602, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy528);}
162391		- yymsp[-5].minor.yy483 = yylhsminor.yy483;
	162554	+{yylhsminor.yy157 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy404, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy504);}
	162555	+ yymsp[-5].minor.yy157 = yylhsminor.yy157;
162392	162556	break;
162393	162557	case 271: /* trigger_cmd ::= scanpt select scanpt */
162394		-{yylhsminor.yy483 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy307, yymsp[-2].minor.yy528, yymsp[0].minor.yy528); /yylhsminor.yy483-overwrites-yymsp[-1].minor.yy307/}
162395		- yymsp[-2].minor.yy483 = yylhsminor.yy483;
	162558	+{yylhsminor.yy157 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy81, yymsp[-2].minor.yy504, yymsp[0].minor.yy504); /yylhsminor.yy157-overwrites-yymsp[-1].minor.yy81/}
	162559	+ yymsp[-2].minor.yy157 = yylhsminor.yy157;
162396	162560	break;
162397	162561	case 272: /* expr ::= RAISE LP IGNORE RP */
162398	162562	{
162399		- yymsp[-3].minor.yy602 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
162400		- if( yymsp[-3].minor.yy602 ){
162401		- yymsp[-3].minor.yy602->affExpr = OE_Ignore;
	162563	+ yymsp[-3].minor.yy404 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
	162564	+ if( yymsp[-3].minor.yy404 ){
	162565	+ yymsp[-3].minor.yy404->affExpr = OE_Ignore;
162402	162566	}
162403	162567	}
162404	162568	break;
162405	162569	case 273: /* expr ::= RAISE LP raisetype COMMA nm RP */
162406	162570	{
162407		- yymsp[-5].minor.yy602 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
162408		- if( yymsp[-5].minor.yy602 ) {
162409		- yymsp[-5].minor.yy602->affExpr = (char)yymsp[-3].minor.yy60;
	162571	+ yymsp[-5].minor.yy404 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
	162572	+ if( yymsp[-5].minor.yy404 ) {
	162573	+ yymsp[-5].minor.yy404->affExpr = (char)yymsp[-3].minor.yy376;
162410	162574	}
162411	162575	}
162412	162576	break;
162413	162577	case 274: /* raisetype ::= ROLLBACK */
162414		-{yymsp[0].minor.yy60 = OE_Rollback;}
	162578	+{yymsp[0].minor.yy376 = OE_Rollback;}
162415	162579	break;
162416	162580	case 276: /* raisetype ::= FAIL */
162417		-{yymsp[0].minor.yy60 = OE_Fail;}
	162581	+{yymsp[0].minor.yy376 = OE_Fail;}
162418	162582	break;
162419	162583	case 277: /* cmd ::= DROP TRIGGER ifexists fullname */
162420	162584	{
162421		- sqlite3DropTrigger(pParse,yymsp[0].minor.yy291,yymsp[-1].minor.yy60);
	162585	+ sqlite3DropTrigger(pParse,yymsp[0].minor.yy153,yymsp[-1].minor.yy376);
162422	162586	}
162423	162587	break;
162424	162588	case 278: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
162425	162589	{
162426		- sqlite3Attach(pParse, yymsp[-3].minor.yy602, yymsp[-1].minor.yy602, yymsp[0].minor.yy602);
	162590	+ sqlite3Attach(pParse, yymsp[-3].minor.yy404, yymsp[-1].minor.yy404, yymsp[0].minor.yy404);
162427	162591	}
162428	162592	break;
162429	162593	case 279: /* cmd ::= DETACH database_kw_opt expr */
162430	162594	{
162431		- sqlite3Detach(pParse, yymsp[0].minor.yy602);
	162595	+ sqlite3Detach(pParse, yymsp[0].minor.yy404);
162432	162596	}
162433	162597	break;
162434	162598	case 282: /* cmd ::= REINDEX */
162435	162599	{sqlite3Reindex(pParse, 0, 0);}
162436	162600	break;
		@@ -162443,11 +162607,11 @@
162443	162607	case 285: /* cmd ::= ANALYZE nm dbnm */
162444	162608	{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
162445	162609	break;
162446	162610	case 286: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
162447	162611	{
162448		- sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy291,&yymsp[0].minor.yy0);
	162612	+ sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy153,&yymsp[0].minor.yy0);
162449	162613	}
162450	162614	break;
162451	162615	case 287: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
162452	162616	{
162453	162617	yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
		@@ -162454,22 +162618,22 @@
162454	162618	sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
162455	162619	}
162456	162620	break;
162457	162621	case 288: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
162458	162622	{
162459		- sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy291, &yymsp[0].minor.yy0);
	162623	+ sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy153, &yymsp[0].minor.yy0);
162460	162624	}
162461	162625	break;
162462	162626	case 289: /* add_column_fullname ::= fullname */
162463	162627	{
162464	162628	disableLookaside(pParse);
162465		- sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy291);
	162629	+ sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy153);
162466	162630	}
162467	162631	break;
162468	162632	case 290: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
162469	162633	{
162470		- sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy291, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
	162634	+ sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy153, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
162471	162635	}
162472	162636	break;
162473	162637	case 291: /* cmd ::= create_vtab */
162474	162638	{sqlite3VtabFinishParse(pParse,0);}
162475	162639	break;
		@@ -162476,11 +162640,11 @@
162476	162640	case 292: /* cmd ::= create_vtab LP vtabarglist RP */
162477	162641	{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
162478	162642	break;
162479	162643	case 293: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
162480	162644	{
162481		- sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy60);
	162645	+ sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy376);
162482	162646	}
162483	162647	break;
162484	162648	case 294: /* vtabarg ::= */
162485	162649	{sqlite3VtabArgInit(pParse);}
162486	162650	break;
		@@ -162489,180 +162653,180 @@
162489	162653	case 297: /* lp ::= LP */ yytestcase(yyruleno==297);
162490	162654	{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
162491	162655	break;
162492	162656	case 298: /* with ::= WITH wqlist */
162493	162657	case 299: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==299);
162494		-{ sqlite3WithPush(pParse, yymsp[0].minor.yy195, 1); }
	162658	+{ sqlite3WithPush(pParse, yymsp[0].minor.yy103, 1); }
162495	162659	break;
162496	162660	case 300: /* wqas ::= AS */
162497		-{yymsp[0].minor.yy570 = M10d_Any;}
	162661	+{yymsp[0].minor.yy552 = M10d_Any;}
162498	162662	break;
162499	162663	case 301: /* wqas ::= AS MATERIALIZED */
162500		-{yymsp[-1].minor.yy570 = M10d_Yes;}
	162664	+{yymsp[-1].minor.yy552 = M10d_Yes;}
162501	162665	break;
162502	162666	case 302: /* wqas ::= AS NOT MATERIALIZED */
162503		-{yymsp[-2].minor.yy570 = M10d_No;}
	162667	+{yymsp[-2].minor.yy552 = M10d_No;}
162504	162668	break;
162505	162669	case 303: /* wqitem ::= nm eidlist_opt wqas LP select RP */
162506	162670	{
162507		- yymsp[-5].minor.yy607 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy338, yymsp[-1].minor.yy307, yymsp[-3].minor.yy570); /A-overwrites-X/
	162671	+ yymsp[-5].minor.yy329 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy70, yymsp[-1].minor.yy81, yymsp[-3].minor.yy552); /A-overwrites-X/
162508	162672	}
162509	162673	break;
162510	162674	case 304: /* wqlist ::= wqitem */
162511	162675	{
162512		- yymsp[0].minor.yy195 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy607); /A-overwrites-X/
	162676	+ yymsp[0].minor.yy103 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy329); /A-overwrites-X/
162513	162677	}
162514	162678	break;
162515	162679	case 305: /* wqlist ::= wqlist COMMA wqitem */
162516	162680	{
162517		- yymsp[-2].minor.yy195 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy195, yymsp[0].minor.yy607);
	162681	+ yymsp[-2].minor.yy103 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy103, yymsp[0].minor.yy329);
162518	162682	}
162519	162683	break;
162520	162684	case 306: /* windowdefn_list ::= windowdefn */
162521		-{ yylhsminor.yy19 = yymsp[0].minor.yy19; }
162522		- yymsp[0].minor.yy19 = yylhsminor.yy19;
	162685	+{ yylhsminor.yy49 = yymsp[0].minor.yy49; }
	162686	+ yymsp[0].minor.yy49 = yylhsminor.yy49;
162523	162687	break;
162524	162688	case 307: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
162525	162689	{
162526		- assert( yymsp[0].minor.yy19!=0 );
162527		- sqlite3WindowChain(pParse, yymsp[0].minor.yy19, yymsp[-2].minor.yy19);
162528		- yymsp[0].minor.yy19->pNextWin = yymsp[-2].minor.yy19;
162529		- yylhsminor.yy19 = yymsp[0].minor.yy19;
	162690	+ assert( yymsp[0].minor.yy49!=0 );
	162691	+ sqlite3WindowChain(pParse, yymsp[0].minor.yy49, yymsp[-2].minor.yy49);
	162692	+ yymsp[0].minor.yy49->pNextWin = yymsp[-2].minor.yy49;
	162693	+ yylhsminor.yy49 = yymsp[0].minor.yy49;
162530	162694	}
162531		- yymsp[-2].minor.yy19 = yylhsminor.yy19;
	162695	+ yymsp[-2].minor.yy49 = yylhsminor.yy49;
162532	162696	break;
162533	162697	case 308: /* windowdefn ::= nm AS LP window RP */
162534	162698	{
162535		- if( ALWAYS(yymsp[-1].minor.yy19) ){
162536		- yymsp[-1].minor.yy19->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
	162699	+ if( ALWAYS(yymsp[-1].minor.yy49) ){
	162700	+ yymsp[-1].minor.yy49->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
162537	162701	}
162538		- yylhsminor.yy19 = yymsp[-1].minor.yy19;
	162702	+ yylhsminor.yy49 = yymsp[-1].minor.yy49;
162539	162703	}
162540		- yymsp[-4].minor.yy19 = yylhsminor.yy19;
	162704	+ yymsp[-4].minor.yy49 = yylhsminor.yy49;
162541	162705	break;
162542	162706	case 309: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
162543	162707	{
162544		- yymsp[-4].minor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, yymsp[-2].minor.yy338, yymsp[-1].minor.yy338, 0);
	162708	+ yymsp[-4].minor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, yymsp[-2].minor.yy70, yymsp[-1].minor.yy70, 0);
162545	162709	}
162546	162710	break;
162547	162711	case 310: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
162548	162712	{
162549		- yylhsminor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, yymsp[-2].minor.yy338, yymsp[-1].minor.yy338, &yymsp[-5].minor.yy0);
	162713	+ yylhsminor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, yymsp[-2].minor.yy70, yymsp[-1].minor.yy70, &yymsp[-5].minor.yy0);
162550	162714	}
162551		- yymsp[-5].minor.yy19 = yylhsminor.yy19;
	162715	+ yymsp[-5].minor.yy49 = yylhsminor.yy49;
162552	162716	break;
162553	162717	case 311: /* window ::= ORDER BY sortlist frame_opt */
162554	162718	{
162555		- yymsp[-3].minor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, 0, yymsp[-1].minor.yy338, 0);
	162719	+ yymsp[-3].minor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, 0, yymsp[-1].minor.yy70, 0);
162556	162720	}
162557	162721	break;
162558	162722	case 312: /* window ::= nm ORDER BY sortlist frame_opt */
162559	162723	{
162560		- yylhsminor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, 0, yymsp[-1].minor.yy338, &yymsp[-4].minor.yy0);
	162724	+ yylhsminor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, 0, yymsp[-1].minor.yy70, &yymsp[-4].minor.yy0);
162561	162725	}
162562		- yymsp[-4].minor.yy19 = yylhsminor.yy19;
	162726	+ yymsp[-4].minor.yy49 = yylhsminor.yy49;
162563	162727	break;
162564	162728	case 313: /* window ::= frame_opt */
162565	162729	case 332: /* filter_over ::= over_clause */ yytestcase(yyruleno==332);
162566	162730	{
162567		- yylhsminor.yy19 = yymsp[0].minor.yy19;
	162731	+ yylhsminor.yy49 = yymsp[0].minor.yy49;
162568	162732	}
162569		- yymsp[0].minor.yy19 = yylhsminor.yy19;
	162733	+ yymsp[0].minor.yy49 = yylhsminor.yy49;
162570	162734	break;
162571	162735	case 314: /* window ::= nm frame_opt */
162572	162736	{
162573		- yylhsminor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, 0, 0, &yymsp[-1].minor.yy0);
	162737	+ yylhsminor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, 0, 0, &yymsp[-1].minor.yy0);
162574	162738	}
162575		- yymsp[-1].minor.yy19 = yylhsminor.yy19;
	162739	+ yymsp[-1].minor.yy49 = yylhsminor.yy49;
162576	162740	break;
162577	162741	case 315: /* frame_opt ::= */
162578	162742	{
162579		- yymsp[1].minor.yy19 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
	162743	+ yymsp[1].minor.yy49 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
162580	162744	}
162581	162745	break;
162582	162746	case 316: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
162583	162747	{
162584		- yylhsminor.yy19 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy60, yymsp[-1].minor.yy113.eType, yymsp[-1].minor.yy113.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy570);
	162748	+ yylhsminor.yy49 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy376, yymsp[-1].minor.yy117.eType, yymsp[-1].minor.yy117.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy552);
162585	162749	}
162586		- yymsp[-2].minor.yy19 = yylhsminor.yy19;
	162750	+ yymsp[-2].minor.yy49 = yylhsminor.yy49;
162587	162751	break;
162588	162752	case 317: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
162589	162753	{
162590		- yylhsminor.yy19 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy60, yymsp[-3].minor.yy113.eType, yymsp[-3].minor.yy113.pExpr, yymsp[-1].minor.yy113.eType, yymsp[-1].minor.yy113.pExpr, yymsp[0].minor.yy570);
	162754	+ yylhsminor.yy49 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy376, yymsp[-3].minor.yy117.eType, yymsp[-3].minor.yy117.pExpr, yymsp[-1].minor.yy117.eType, yymsp[-1].minor.yy117.pExpr, yymsp[0].minor.yy552);
162591	162755	}
162592		- yymsp[-5].minor.yy19 = yylhsminor.yy19;
	162756	+ yymsp[-5].minor.yy49 = yylhsminor.yy49;
162593	162757	break;
162594	162758	case 319: /* frame_bound_s ::= frame_bound */
162595	162759	case 321: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==321);
162596		-{yylhsminor.yy113 = yymsp[0].minor.yy113;}
162597		- yymsp[0].minor.yy113 = yylhsminor.yy113;
	162760	+{yylhsminor.yy117 = yymsp[0].minor.yy117;}
	162761	+ yymsp[0].minor.yy117 = yylhsminor.yy117;
162598	162762	break;
162599	162763	case 320: /* frame_bound_s ::= UNBOUNDED PRECEDING */
162600	162764	case 322: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==322);
162601	162765	case 324: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==324);
162602		-{yylhsminor.yy113.eType = yymsp[-1].major; yylhsminor.yy113.pExpr = 0;}
162603		- yymsp[-1].minor.yy113 = yylhsminor.yy113;
	162766	+{yylhsminor.yy117.eType = yymsp[-1].major; yylhsminor.yy117.pExpr = 0;}
	162767	+ yymsp[-1].minor.yy117 = yylhsminor.yy117;
162604	162768	break;
162605	162769	case 323: /* frame_bound ::= expr PRECEDING\|FOLLOWING */
162606		-{yylhsminor.yy113.eType = yymsp[0].major; yylhsminor.yy113.pExpr = yymsp[-1].minor.yy602;}
162607		- yymsp[-1].minor.yy113 = yylhsminor.yy113;
	162770	+{yylhsminor.yy117.eType = yymsp[0].major; yylhsminor.yy117.pExpr = yymsp[-1].minor.yy404;}
	162771	+ yymsp[-1].minor.yy117 = yylhsminor.yy117;
162608	162772	break;
162609	162773	case 325: /* frame_exclude_opt ::= */
162610		-{yymsp[1].minor.yy570 = 0;}
	162774	+{yymsp[1].minor.yy552 = 0;}
162611	162775	break;
162612	162776	case 326: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
162613		-{yymsp[-1].minor.yy570 = yymsp[0].minor.yy570;}
	162777	+{yymsp[-1].minor.yy552 = yymsp[0].minor.yy552;}
162614	162778	break;
162615	162779	case 327: /* frame_exclude ::= NO OTHERS */
162616	162780	case 328: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==328);
162617		-{yymsp[-1].minor.yy570 = yymsp[-1].major; /A-overwrites-X/}
	162781	+{yymsp[-1].minor.yy552 = yymsp[-1].major; /A-overwrites-X/}
162618	162782	break;
162619	162783	case 329: /* frame_exclude ::= GROUP\|TIES */
162620		-{yymsp[0].minor.yy570 = yymsp[0].major; /A-overwrites-X/}
	162784	+{yymsp[0].minor.yy552 = yymsp[0].major; /A-overwrites-X/}
162621	162785	break;
162622	162786	case 330: /* window_clause ::= WINDOW windowdefn_list */
162623		-{ yymsp[-1].minor.yy19 = yymsp[0].minor.yy19; }
	162787	+{ yymsp[-1].minor.yy49 = yymsp[0].minor.yy49; }
162624	162788	break;
162625	162789	case 331: /* filter_over ::= filter_clause over_clause */
162626	162790	{
162627		- if( yymsp[0].minor.yy19 ){
162628		- yymsp[0].minor.yy19->pFilter = yymsp[-1].minor.yy602;
	162791	+ if( yymsp[0].minor.yy49 ){
	162792	+ yymsp[0].minor.yy49->pFilter = yymsp[-1].minor.yy404;
162629	162793	}else{
162630		- sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy602);
	162794	+ sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy404);
162631	162795	}
162632		- yylhsminor.yy19 = yymsp[0].minor.yy19;
	162796	+ yylhsminor.yy49 = yymsp[0].minor.yy49;
162633	162797	}
162634		- yymsp[-1].minor.yy19 = yylhsminor.yy19;
	162798	+ yymsp[-1].minor.yy49 = yylhsminor.yy49;
162635	162799	break;
162636	162800	case 333: /* filter_over ::= filter_clause */
162637	162801	{
162638		- yylhsminor.yy19 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
162639		- if( yylhsminor.yy19 ){
162640		- yylhsminor.yy19->eFrmType = TK_FILTER;
162641		- yylhsminor.yy19->pFilter = yymsp[0].minor.yy602;
	162802	+ yylhsminor.yy49 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
	162803	+ if( yylhsminor.yy49 ){
	162804	+ yylhsminor.yy49->eFrmType = TK_FILTER;
	162805	+ yylhsminor.yy49->pFilter = yymsp[0].minor.yy404;
162642	162806	}else{
162643		- sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy602);
	162807	+ sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy404);
162644	162808	}
162645	162809	}
162646		- yymsp[0].minor.yy19 = yylhsminor.yy19;
	162810	+ yymsp[0].minor.yy49 = yylhsminor.yy49;
162647	162811	break;
162648	162812	case 334: /* over_clause ::= OVER LP window RP */
162649	162813	{
162650		- yymsp[-3].minor.yy19 = yymsp[-1].minor.yy19;
162651		- assert( yymsp[-3].minor.yy19!=0 );
	162814	+ yymsp[-3].minor.yy49 = yymsp[-1].minor.yy49;
	162815	+ assert( yymsp[-3].minor.yy49!=0 );
162652	162816	}
162653	162817	break;
162654	162818	case 335: /* over_clause ::= OVER nm */
162655	162819	{
162656		- yymsp[-1].minor.yy19 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
162657		- if( yymsp[-1].minor.yy19 ){
162658		- yymsp[-1].minor.yy19->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
	162820	+ yymsp[-1].minor.yy49 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
	162821	+ if( yymsp[-1].minor.yy49 ){
	162822	+ yymsp[-1].minor.yy49->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
162659	162823	}
162660	162824	}
162661	162825	break;
162662	162826	case 336: /* filter_clause ::= FILTER LP WHERE expr RP */
162663		-{ yymsp[-4].minor.yy602 = yymsp[-1].minor.yy602; }
	162827	+{ yymsp[-4].minor.yy404 = yymsp[-1].minor.yy404; }
162664	162828	break;
162665	162829	default:
162666	162830	/* (337) input ::= cmdlist */ yytestcase(yyruleno==337);
162667	162831	/* (338) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==338);
162668	162832	/* (339) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=339);
		@@ -191338,12 +191502,12 @@
191338	191502	if( pStr->zBuf==0 ){
191339	191503	jsonInit(pStr, ctx);
191340	191504	jsonAppendChar(pStr, '{');
191341	191505	}else if( pStr->nUsed>1 ){
191342	191506	jsonAppendChar(pStr, ',');
191343		- pStr->pCtx = ctx;
191344	191507	}
	191508	+ pStr->pCtx = ctx;
191345	191509	z = (const char*)sqlite3_value_text(argv[0]);
191346	191510	n = (u32)sqlite3_value_bytes(argv[0]);
191347	191511	jsonAppendString(pStr, z, n);
191348	191512	jsonAppendChar(pStr, ':');
191349	191513	jsonAppendValue(pStr, argv[1]);
		@@ -208318,17 +208482,33 @@
208318	208482	** If not, use sqlite3_realloc() to grow the buffer so that there is.
208319	208483	**
208320	208484	** If successful, return zero. Otherwise, if an OOM condition is encountered,
208321	208485	** set *pRc to SQLITE_NOMEM and return non-zero.
208322	208486	*/
208323		-static int sessionBufferGrow(SessionBuffer p, size_t nByte, int pRc){
208324		- if( *pRc==SQLITE_OK && (size_t)(p->nAlloc-p->nBuf)<nByte ){
	208487	+static int sessionBufferGrow(SessionBuffer p, i64 nByte, int pRc){
	208488	+#define SESSION_MAX_BUFFER_SZ (0x7FFFFF00 - 1)
	208489	+ i64 nReq = p->nBuf + nByte;
	208490	+ if( *pRc==SQLITE_OK && nReq>p->nAlloc ){
208325	208491	u8 *aNew;
208326	208492	i64 nNew = p->nAlloc ? p->nAlloc : 128;
	208493	+
208327	208494	do {
208328	208495	nNew = nNew*2;
208329		- }while( (size_t)(nNew-p->nBuf)<nByte );
	208496	+ }while( nNew<nReq );
	208497	+
	208498	+ /* The value of SESSION_MAX_BUFFER_SZ is copied from the implementation
	208499	+ ** of sqlite3_realloc64(). Allocations greater than this size in bytes
	208500	+ ** always fail. It is used here to ensure that this routine can always
	208501	+ ** allocate up to this limit - instead of up to the largest power of
	208502	+ ** two smaller than the limit. */
	208503	+ if( nNew>SESSION_MAX_BUFFER_SZ ){
	208504	+ nNew = SESSION_MAX_BUFFER_SZ;
	208505	+ if( nNew<nReq ){
	208506	+ *pRc = SQLITE_NOMEM;
	208507	+ return 1;
	208508	+ }
	208509	+ }
208330	208510
208331	208511	aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
208332	208512	if( 0==aNew ){
208333	208513	*pRc = SQLITE_NOMEM;
208334	208514	}else{
		@@ -229418,17 +229598,19 @@
229418	229598	}
229419	229599	if( iBest<0 ) break;
229420	229600
229421	229601	nInst++;
229422	229602	if( nInst>=pCsr->nInstAlloc ){
229423		- pCsr->nInstAlloc = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
	229603	+ int nNewSize = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
229424	229604	aInst = (int*)sqlite3_realloc64(
229425		- pCsr->aInst, pCsr->nInstAllocsizeof(int)3
	229605	+ pCsr->aInst, nNewSizesizeof(int)3
229426	229606	);
229427	229607	if( aInst ){
229428	229608	pCsr->aInst = aInst;
	229609	+ pCsr->nInstAlloc = nNewSize;
229429	229610	}else{
	229611	+ nInst--;
229430	229612	rc = SQLITE_NOMEM;
229431	229613	break;
229432	229614	}
229433	229615	}
229434	229616
		@@ -230259,11 +230441,11 @@
230259	230441	int nArg, /* Number of args */
230260	230442	sqlite3_value *apUnused / Function arguments */
230261	230443	){
230262	230444	assert( nArg==0 );
230263	230445	UNUSED_PARAM2(nArg, apUnused);
230264		- sqlite3_result_text(pCtx, "fts5: 2021-05-14 15:37:00 cf63abbe559d04f993f99a37d41ba4a97c0261094f1d4cc05cfa23b1e11731f5", -1, SQLITE_TRANSIENT);
	230446	+ sqlite3_result_text(pCtx, "fts5: 2021-06-03 18:56:42 4a587c3492faa99490fd67ca1de9fceafcdc12d220f42817791923be258b73f1", -1, SQLITE_TRANSIENT);
230265	230447	}
230266	230448
230267	230449	/*
230268	230450	** Return true if zName is the extension on one of the shadow tables used
230269	230451	** by this module.
		@@ -235185,12 +235367,12 @@
235185	235367	}
235186	235368	#endif /* SQLITE_CORE */
235187	235369	#endif /* !defined(SQLITE_CORE) \|\| defined(SQLITE_ENABLE_STMTVTAB) */
235188	235370
235189	235371	/************ End of stmt.c **********************************************/
235190		-#if __LINE__!=235190
	235372	+#if __LINE__!=235372
235191	235373	#undef SQLITE_SOURCE_ID
235192		-#define SQLITE_SOURCE_ID "2021-05-17 17:14:38 ace12a3912a4fdc2f0e741361ec705652a11b6f5e3548d54bd6f273671baalt2"
	235374	+#define SQLITE_SOURCE_ID "2021-06-03 18:56:42 4a587c3492faa99490fd67ca1de9fceafcdc12d220f42817791923be258balt2"
235193	235375	#endif
235194	235376	/* Return the source-id for this library */
235195	235377	SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
235196	235378	/************************ End of sqlite3.c ****************************/
235197	235379

	--- src/sqlite3.c
	+++ src/sqlite3.c
	@@ -81,12 +81,14 @@
81	"4_BYTE_ALIGNED_MALLOC",
82	#endif
83	#if SQLITE_64BIT_STATS
84	"64BIT_STATS",
85	#endif
86	#if SQLITE_ALLOW_COVERING_INDEX_SCAN
87	"ALLOW_COVERING_INDEX_SCAN",


88	#endif
89	#if SQLITE_ALLOW_URI_AUTHORITY
90	"ALLOW_URI_AUTHORITY",
91	#endif
92	#ifdef SQLITE_BITMASK_TYPE
	@@ -144,12 +146,14 @@
144	"DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
145	#endif
146	#ifdef SQLITE_DEFAULT_LOOKASIDE
147	"DEFAULT_LOOKASIDE=" CTIMEOPT_VAL2(SQLITE_DEFAULT_LOOKASIDE),
148	#endif
149	#if SQLITE_DEFAULT_MEMSTATUS
150	"DEFAULT_MEMSTATUS",


151	#endif
152	#ifdef SQLITE_DEFAULT_MMAP_SIZE
153	"DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),
154	#endif
155	#ifdef SQLITE_DEFAULT_PAGE_SIZE
	@@ -219,11 +223,11 @@
219	"ENABLE_BATCH_ATOMIC_WRITE",
220	#endif
221	#if SQLITE_ENABLE_BYTECODE_VTAB
222	"ENABLE_BYTECODE_VTAB",
223	#endif
224	#if SQLITE_ENABLE_CEROD
225	"ENABLE_CEROD=" CTIMEOPT_VAL(SQLITE_ENABLE_CEROD),
226	#endif
227	#if SQLITE_ENABLE_COLUMN_METADATA
228	"ENABLE_COLUMN_METADATA",
229	#endif
	@@ -233,22 +237,22 @@
233	#if SQLITE_ENABLE_COSTMULT
234	"ENABLE_COSTMULT",
235	#endif
236	#if SQLITE_ENABLE_CURSOR_HINTS
237	"ENABLE_CURSOR_HINTS",



238	#endif
239	#if SQLITE_ENABLE_DBSTAT_VTAB
240	"ENABLE_DBSTAT_VTAB",
241	#endif
242	#if SQLITE_ENABLE_EXPENSIVE_ASSERT
243	"ENABLE_EXPENSIVE_ASSERT",
244	#endif
245	#if SQLITE_ENABLE_FTS1
246	"ENABLE_FTS1",
247	#endif
248	#if SQLITE_ENABLE_FTS2
249	"ENABLE_FTS2",
250	#endif
251	#if SQLITE_ENABLE_FTS3
252	"ENABLE_FTS3",
253	#endif
254	#if SQLITE_ENABLE_FTS3_PARENTHESIS
	@@ -302,10 +306,13 @@
302	#if SQLITE_ENABLE_NORMALIZE
303	"ENABLE_NORMALIZE",
304	#endif
305	#if SQLITE_ENABLE_NULL_TRIM
306	"ENABLE_NULL_TRIM",



307	#endif
308	#if SQLITE_ENABLE_OVERSIZE_CELL_CHECK
309	"ENABLE_OVERSIZE_CELL_CHECK",
310	#endif
311	#if SQLITE_ENABLE_PREUPDATE_HOOK
	@@ -333,11 +340,11 @@
333	"ENABLE_SORTER_REFERENCES",
334	#endif
335	#if SQLITE_ENABLE_SQLLOG
336	"ENABLE_SQLLOG",
337	#endif
338	#if defined(SQLITE_ENABLE_STAT4)
339	"ENABLE_STAT4",
340	#endif
341	#if SQLITE_ENABLE_STMTVTAB
342	"ENABLE_STMTVTAB",
343	#endif
	@@ -387,12 +394,14 @@
387	"FTS5_NO_WITHOUT_ROWID",
388	#endif
389	#if HAVE_ISNAN \|\| SQLITE_HAVE_ISNAN
390	"HAVE_ISNAN",
391	#endif
392	#if SQLITE_HOMEGROWN_RECURSIVE_MUTEX
393	"HOMEGROWN_RECURSIVE_MUTEX",


394	#endif
395	#if SQLITE_IGNORE_AFP_LOCK_ERRORS
396	"IGNORE_AFP_LOCK_ERRORS",
397	#endif
398	#if SQLITE_IGNORE_FLOCK_LOCK_ERRORS
	@@ -486,13 +495,10 @@
486	"MMAP_READWRITE",
487	#endif
488	#if SQLITE_MUTEX_NOOP
489	"MUTEX_NOOP",
490	#endif
491	#if SQLITE_MUTEX_NREF
492	"MUTEX_NREF",
493	#endif
494	#if SQLITE_MUTEX_OMIT
495	"MUTEX_OMIT",
496	#endif
497	#if SQLITE_MUTEX_PTHREADS
498	"MUTEX_PTHREADS",
	@@ -558,18 +564,21 @@
558	"OMIT_CONFLICT_CLAUSE",
559	#endif
560	#if SQLITE_OMIT_CTE
561	"OMIT_CTE",
562	#endif
563	#if SQLITE_OMIT_DATETIME_FUNCS
564	"OMIT_DATETIME_FUNCS",
565	#endif
566	#if SQLITE_OMIT_DECLTYPE
567	"OMIT_DECLTYPE",
568	#endif
569	#if SQLITE_OMIT_DEPRECATED
570	"OMIT_DEPRECATED",



571	#endif
572	#if SQLITE_OMIT_DISKIO
573	"OMIT_DISKIO",
574	#endif
575	#if SQLITE_OMIT_EXPLAIN
	@@ -593,10 +602,13 @@
593	#if SQLITE_OMIT_INCRBLOB
594	"OMIT_INCRBLOB",
595	#endif
596	#if SQLITE_OMIT_INTEGRITY_CHECK
597	"OMIT_INTEGRITY_CHECK",



598	#endif
599	#if SQLITE_OMIT_LIKE_OPTIMIZATION
600	"OMIT_LIKE_OPTIMIZATION",
601	#endif
602	#if SQLITE_OMIT_LOAD_EXTENSION
	@@ -657,12 +669,14 @@
657	"OMIT_TEMPDB",
658	#endif
659	#if SQLITE_OMIT_TEST_CONTROL
660	"OMIT_TEST_CONTROL",
661	#endif
662	#if SQLITE_OMIT_TRACE
663	"OMIT_TRACE",


664	#endif
665	#if SQLITE_OMIT_TRIGGER
666	"OMIT_TRIGGER",
667	#endif
668	#if SQLITE_OMIT_TRUNCATE_OPTIMIZATION
	@@ -693,12 +707,14 @@
693	"PCACHE_SEPARATE_HEADER",
694	#endif
695	#if SQLITE_PERFORMANCE_TRACE
696	"PERFORMANCE_TRACE",
697	#endif
698	#if SQLITE_POWERSAFE_OVERWRITE
699	"POWERSAFE_OVERWRITE",


700	#endif
701	#if SQLITE_PREFER_PROXY_LOCKING
702	"PREFER_PROXY_LOCKING",
703	#endif
704	#if SQLITE_PROXY_DEBUG
	@@ -729,11 +745,14 @@
729	"STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL),
730	#endif
731	#if SQLITE_SUBSTR_COMPATIBILITY
732	"SUBSTR_COMPATIBILITY",
733	#endif
734	#if SQLITE_SYSTEM_MALLOC



735	"SYSTEM_MALLOC",
736	#endif
737	#if SQLITE_TCL
738	"TCL",
739	#endif
	@@ -1186,11 +1205,11 @@
1186	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
1187	** [sqlite_version()] and [sqlite_source_id()].
1188	*/
1189	#define SQLITE_VERSION "3.36.0"
1190	#define SQLITE_VERSION_NUMBER 3036000
1191	#define SQLITE_SOURCE_ID "2021-05-17 17:14:38 ace12a3912a4fdc2f0e741361ec705652a11b6f5e3548d54bd6f273671ba1e09"
1192
1193	/*
1194	** CAPI3REF: Run-Time Library Version Numbers
1195	** KEYWORDS: sqlite3_version sqlite3_sourceid
1196	**
	@@ -14310,12 +14329,13 @@
14310	#define TK_VECTOR 176
14311	#define TK_SELECT_COLUMN 177
14312	#define TK_IF_NULL_ROW 178
14313	#define TK_ASTERISK 179
14314	#define TK_SPAN 180
14315	#define TK_SPACE 181
14316	#define TK_ILLEGAL 182

14317
14318	/************ End of parse.h *********************************************/
14319	/************ Continuing where we left off in sqliteInt.h ****************/
14320	#include <stdio.h>
14321	#include <stdlib.h>
	@@ -16006,11 +16026,11 @@
16006	/* 152 */ 0x10, 0x10, 0x00, 0x04, 0x1a, 0x00, 0x00, 0x00,\
16007	/* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
16008	/* 168 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
16009	/* 176 */ 0x00, 0x00, 0x00, 0x00,}
16010
16011	/* The sqlite3P2Values() routine is able to run faster if it knows
16012	** the value of the largest JUMP opcode. The smaller the maximum
16013	** JUMP opcode the better, so the mkopcodeh.tcl script that
16014	** generated this include file strives to group all JUMP opcodes
16015	** together near the beginning of the list.
16016	*/
	@@ -18511,10 +18531,11 @@
18511	unsigned isCorrelated :1; /* True if sub-query is correlated */
18512	unsigned viaCoroutine :1; /* Implemented as a co-routine */
18513	unsigned isRecursive :1; /* True for recursive reference in WITH */
18514	unsigned fromDDL :1; /* Comes from sqlite_schema */
18515	unsigned isCte :1; /* This is a CTE */

18516	} fg;
18517	int iCursor; /* The VDBE cursor number used to access this table */
18518	Expr pOn; / The ON clause of a join */
18519	IdList pUsing; / The USING clause of a join */
18520	Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */
	@@ -19488,10 +19509,11 @@
19488	** An instance of the With object represents a WITH clause containing
19489	** one or more CTEs (common table expressions).
19490	*/
19491	struct With {
19492	int nCte; /* Number of CTEs in the WITH clause */

19493	With pOuter; / Containing WITH clause, or NULL */
19494	Cte a[1]; /* For each CTE in the WITH clause.... */
19495	};
19496
19497	/*
	@@ -19880,10 +19902,11 @@
19880	SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3*);
19881	SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3*,int);
19882	SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3*);
19883	SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
19884	SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3,Table);

19885	SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse,ExprList,i16,Column*);
19886	SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(Parse,Table,Select*,char);
19887	SQLITE_PRIVATE Table sqlite3ResultSetOfSelect(Parse,Select*,char);
19888	SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *, int);
19889	SQLITE_PRIVATE Index sqlite3PrimaryKeyIndex(Table);
	@@ -27891,11 +27914,10 @@
27891	SQLITE_PRIVATE int sqlite3MallocInit(void){
27892	int rc;
27893	if( sqlite3GlobalConfig.m.xMalloc==0 ){
27894	sqlite3MemSetDefault();
27895	}
27896	memset(&mem0, 0, sizeof(mem0));
27897	mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
27898	if( sqlite3GlobalConfig.pPage==0 \|\| sqlite3GlobalConfig.szPage<512
27899	\|\| sqlite3GlobalConfig.nPage<=0 ){
27900	sqlite3GlobalConfig.pPage = 0;
27901	sqlite3GlobalConfig.szPage = 0;
	@@ -30588,10 +30610,18 @@
30588	}
30589	case TK_IF_NULL_ROW: {
30590	sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable);
30591	sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30592	break;








30593	}
30594	default: {
30595	sqlite3TreeViewLine(pView, "op=%d", pExpr->op);
30596	break;
30597	}
	@@ -42058,10 +42088,26 @@
42058	/* Register all VFSes defined in the aVfs[] array */
42059	for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
42060	sqlite3_vfs_register(&aVfs[i], i==0);
42061	}
42062	unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
















42063	return SQLITE_OK;
42064	}
42065
42066	/*
42067	** Shutdown the operating system interface.
	@@ -48523,16 +48569,16 @@
48523	MemStore pStore; / The storage */
48524	int eLock; /* Most recent lock against this file */
48525	};
48526
48527	/*
48528	** Global variables for holding the memdb files that are accessible
48529	** to multiple database connections in separate threads.
48530	**
48531	** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object.
48532	*/
48533	struct MemFS {
48534	int nMemStore; /* Number of shared MemStore objects */
48535	MemStore *apMemStore; / Array of all shared MemStore objects */
48536	} memdb_g;
48537
48538	/*
	@@ -74858,12 +74904,12 @@
74858	if( rc ) goto cleardatabasepage_out;
74859	}
74860	if( !pPage->leaf ){
74861	rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
74862	if( rc ) goto cleardatabasepage_out;
74863	}else if( pnChange ){
74864	assert( pPage->intKey \|\| CORRUPT_DB );
74865	testcase( !pPage->intKey );
74866	*pnChange += pPage->nCell;
74867	}
74868	if( freePageFlag ){
74869	freePage(pPage, &rc);
	@@ -74884,13 +74930,12 @@
74884	**
74885	** This routine will fail with SQLITE_LOCKED if there are any open
74886	** read cursors on the table. Open write cursors are moved to the
74887	** root of the table.
74888	**
74889	** If pnChange is not NULL, then table iTable must be an intkey table. The
74890	** integer value pointed to by pnChange is incremented by the number of
74891	** entries in the table.
74892	*/
74893	SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree p, int iTable, int pnChange){
74894	int rc;
74895	BtShared *pBt = p->pBt;
74896	sqlite3BtreeEnter(p);
	@@ -86924,11 +86969,11 @@
86924	printf(" <== R[%d]", (int)(p->pScopyFrom - &p[-iReg]));
86925	}
86926	printf("\n");
86927	sqlite3VdbeCheckMemInvariants(p);
86928	}
86929	SQLITE_PRIVATE void sqlite3PrintMem(Mem *pMem){
86930	memTracePrint(pMem);
86931	printf("\n");
86932	fflush(stdout);
86933	}
86934	#endif
	@@ -88466,11 +88511,11 @@
88466	pIn1 = &aMem[pOp->p1];
88467	pIn3 = &aMem[pOp->p3];
88468	flags1 = pIn1->flags;
88469	flags3 = pIn3->flags;
88470	if( (flags1 & flags3 & MEM_Int)!=0 ){
88471	assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT );
88472	/* Common case of comparison of two integers */
88473	if( pIn3->u.i > pIn1->u.i ){
88474	iCompare = +1;
88475	if( sqlite3aGTb[pOp->opcode] ){
88476	VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
	@@ -92663,15 +92708,14 @@
92663	**
92664	** The table being clear is in the main database file if P2==0. If
92665	** P2==1 then the table to be clear is in the auxiliary database file
92666	** that is used to store tables create using CREATE TEMPORARY TABLE.
92667	**
92668	** If the P3 value is non-zero, then the table referred to must be an
92669	** intkey table (an SQL table, not an index). In this case the row change
92670	** count is incremented by the number of rows in the table being cleared.
92671	** If P3 is greater than zero, then the value stored in register P3 is
92672	** also incremented by the number of rows in the table being cleared.
92673	**
92674	** See also: Destroy
92675	*/
92676	case OP_Clear: {
92677	int nChange;
	@@ -92678,13 +92722,11 @@
92678
92679	sqlite3VdbeIncrWriteCounter(p, 0);
92680	nChange = 0;
92681	assert( p->readOnly==0 );
92682	assert( DbMaskTest(p->btreeMask, pOp->p2) );
92683	rc = sqlite3BtreeClearTable(
92684	db->aDb[pOp->p2].pBt, (u32)pOp->p1, (pOp->p3 ? &nChange : 0)
92685	);
92686	if( pOp->p3 ){
92687	p->nChange += nChange;
92688	if( pOp->p3>0 ){
92689	assert( memIsValid(&aMem[pOp->p3]) );
92690	memAboutToChange(p, &aMem[pOp->p3]);
	@@ -93668,10 +93710,11 @@
93668
93669	pBt = db->aDb[pOp->p1].pBt;
93670	pPager = sqlite3BtreePager(pBt);
93671	eOld = sqlite3PagerGetJournalMode(pPager);
93672	if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;

93673	if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
93674
93675	#ifndef SQLITE_OMIT_WAL
93676	zFilename = sqlite3PagerFilename(pPager, 1);
93677
	@@ -98688,30 +98731,32 @@
98688	/*
98689	** Truncate the in-memory file.
98690	*/
98691	static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
98692	MemJournal p = (MemJournal )pJfd;
98693	FileChunk *pIter = 0;
98694
98695	if( size==0 ){
98696	memjrnlFreeChunks(p->pFirst);
98697	p->pFirst = 0;
98698	}else{
98699	i64 iOff = p->nChunkSize;
98700	for(pIter=p->pFirst; ALWAYS(pIter) && iOff<=size; pIter=pIter->pNext){
98701	iOff += p->nChunkSize;
98702	}
98703	if( ALWAYS(pIter) ){
98704	memjrnlFreeChunks(pIter->pNext);
98705	pIter->pNext = 0;
98706	}
98707	}
98708
98709	p->endpoint.pChunk = pIter;
98710	p->endpoint.iOffset = size;
98711	p->readpoint.pChunk = 0;
98712	p->readpoint.iOffset = 0;


98713	return SQLITE_OK;
98714	}
98715
98716	/*
98717	** Close the file.
	@@ -100390,11 +100435,11 @@
100390	nc.uNC.pEList = pEList;
100391	nc.ncFlags = NC_AllowAgg\|NC_UEList\|NC_NoSelect;
100392	nc.nNcErr = 0;
100393	db = pParse->db;
100394	savedSuppErr = db->suppressErr;
100395	if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1;
100396	rc = sqlite3ResolveExprNames(&nc, pE);
100397	db->suppressErr = savedSuppErr;
100398	if( rc ) return 0;
100399
100400	/* Try to match the ORDER BY expression against an expression
	@@ -100489,33 +100534,28 @@
100489	** expression, resolving any symbols in it, and then comparing
100490	** it against each expression returned by the SELECT statement.
100491	** Once the comparisons are finished, the duplicate expression
100492	** is deleted.
100493	**
100494	** Or, if this is running as part of an ALTER TABLE operation,
100495	** resolve the symbols in the actual expression, not a duplicate.
100496	** And, if one of the comparisons is successful, leave the expression
100497	** as is instead of transforming it to an integer as in the usual
100498	** case. This allows the code in alter.c to modify column
100499	** refererences within the ORDER BY expression as required. */
100500	if( IN_RENAME_OBJECT ){
100501	pDup = pE;
100502	}else{
100503	pDup = sqlite3ExprDup(db, pE, 0);
100504	}
100505	if( !db->mallocFailed ){
100506	assert(pDup);
100507	iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);



100508	}
100509	if( !IN_RENAME_OBJECT ){
100510	sqlite3ExprDelete(db, pDup);
100511	}
100512	}
100513	}
100514	if( iCol>0 ){
100515	/* Convert the ORDER BY term into an integer column number iCol,
100516	** taking care to preserve the COLLATE clause if it exists */
100517	if( !IN_RENAME_OBJECT ){
100518	Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
100519	if( pNew==0 ) return 1;
100520	pNew->flags \|= EP_IntValue;
100521	pNew->u.iValue = iCol;
	@@ -101595,11 +101635,11 @@
101595	** just the expression for the i-th term of the result set, and may
101596	** not be ready for evaluation because the table cursor has not yet
101597	** been positioned.
101598	*/
101599	SQLITE_PRIVATE Expr sqlite3VectorFieldSubexpr(Expr pVector, int i){
101600	assert( i<sqlite3ExprVectorSize(pVector) );
101601	if( sqlite3ExprIsVector(pVector) ){
101602	assert( pVector->op2==0 \|\| pVector->op==TK_REGISTER );
101603	if( pVector->op==TK_SELECT \|\| pVector->op2==TK_SELECT ){
101604	return pVector->x.pSelect->pEList->a[i].pExpr;
101605	}else{
	@@ -101711,21 +101751,24 @@
101711	int regSelect, /* First in array of registers */
101712	Expr *ppExpr, / OUT: Expression element */
101713	int pRegFree / OUT: Temp register to free */
101714	){
101715	u8 op = pVector->op;
101716	assert( op==TK_VECTOR \|\| op==TK_REGISTER \|\| op==TK_SELECT );
101717	if( op==TK_REGISTER ){
101718	*ppExpr = sqlite3VectorFieldSubexpr(pVector, iField);
101719	return pVector->iTable+iField;
101720	}
101721	if( op==TK_SELECT ){
101722	*ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
101723	return regSelect+iField;
101724	}
101725	*ppExpr = pVector->x.pList->a[iField].pExpr;
101726	return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree);



101727	}
101728
101729	/*
101730	** Expression pExpr is a comparison between two vector values. Compute
101731	** the result of the comparison (1, 0, or NULL) and write that
	@@ -102658,11 +102701,12 @@
102658	&& pOldExpr->op==TK_SELECT_COLUMN
102659	&& (pNewExpr = pItem->pExpr)!=0
102660	){
102661	assert( pNewExpr->iColumn==0 \|\| i>0 );
102662	if( pNewExpr->iColumn==0 ){
102663	assert( pOldExpr->pLeft==pOldExpr->pRight );

102664	pPriorSelectCol = pNewExpr->pLeft = pNewExpr->pRight;
102665	}else{
102666	assert( i>0 );
102667	assert( pItem[-1].pExpr!=0 );
102668	assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 );
	@@ -104131,23 +104175,27 @@
104131	addrOnce?"":"CORRELATED ", pSelect->selId
104132	));
104133	/* If the LHS and RHS of the IN operator do not match, that
104134	** error will have been caught long before we reach this point. */
104135	if( ALWAYS(pEList->nExpr==nVal) ){

104136	SelectDest dest;
104137	int i;

104138	sqlite3SelectDestInit(&dest, SRT_Set, iTab);
104139	dest.zAffSdst = exprINAffinity(pParse, pExpr);
104140	pSelect->iLimit = 0;
104141	testcase( pSelect->selFlags & SF_Distinct );
104142	testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
104143	if( sqlite3Select(pParse, pSelect, &dest) ){
104144	sqlite3DbFree(pParse->db, dest.zAffSdst);



104145	sqlite3KeyInfoUnref(pKeyInfo);
104146	return;
104147	}
104148	sqlite3DbFree(pParse->db, dest.zAffSdst);
104149	assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
104150	assert( pEList!=0 );
104151	assert( pEList->nExpr>0 );
104152	assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
104153	for(i=0; i<nVal; i++){
	@@ -104242,15 +104290,33 @@
104242	int nReg; /* Registers to allocate */
104243	Expr pLimit; / New limit expression */
104244
104245	Vdbe *v = pParse->pVdbe;
104246	assert( v!=0 );

104247	testcase( pExpr->op==TK_EXISTS );
104248	testcase( pExpr->op==TK_SELECT );
104249	assert( pExpr->op==TK_EXISTS \|\| pExpr->op==TK_SELECT );
104250	assert( ExprHasProperty(pExpr, EP_xIsSelect) );
104251	pSel = pExpr->x.pSelect;

















104252
104253	/* The evaluation of the EXISTS/SELECT must be repeated every time it
104254	** is encountered if any of the following is true:
104255	**
104256	** * The right-hand side is a correlated subquery
	@@ -104259,26 +104325,10 @@
104259	**
104260	** If all of the above are false, then we can run this code just once
104261	** save the results, and reuse the same result on subsequent invocations.
104262	*/
104263	if( !ExprHasProperty(pExpr, EP_VarSelect) ){
104264	/* If this routine has already been coded, then invoke it as a
104265	** subroutine. */
104266	if( ExprHasProperty(pExpr, EP_Subrtn) ){
104267	ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId));
104268	sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
104269	pExpr->y.sub.iAddr);
104270	return pExpr->iTable;
104271	}
104272
104273	/* Begin coding the subroutine */
104274	ExprSetProperty(pExpr, EP_Subrtn);
104275	pExpr->y.sub.regReturn = ++pParse->nMem;
104276	pExpr->y.sub.iAddr =
104277	sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
104278	VdbeComment((v, "return address"));
104279
104280	addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
104281	}
104282
104283	/* For a SELECT, generate code to put the values for all columns of
104284	** the first row into an array of registers and return the index of
	@@ -104323,23 +104373,26 @@
104323	pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1");
104324	pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0);
104325	}
104326	pSel->iLimit = 0;
104327	if( sqlite3Select(pParse, pSel, &dest) ){




104328	return 0;
104329	}
104330	pExpr->iTable = rReg = dest.iSDParm;
104331	ExprSetVVAProperty(pExpr, EP_NoReduce);
104332	if( addrOnce ){
104333	sqlite3VdbeJumpHere(v, addrOnce);
104334
104335	/* Subroutine return */
104336	sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
104337	sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
104338	sqlite3ClearTempRegCache(pParse);
104339	}
104340




104341	return rReg;
104342	}
104343	#endif /* SQLITE_OMIT_SUBQUERY */
104344
104345	#ifndef SQLITE_OMIT_SUBQUERY
	@@ -105166,11 +105219,11 @@
105166	default: {
105167	/* Make NULL the default case so that if a bug causes an illegal
105168	** Expr node to be passed into this function, it will be handled
105169	** sanely and not crash. But keep the assert() to bring the problem
105170	** to the attention of the developers. */
105171	assert( op==TK_NULL \|\| pParse->db->mallocFailed );
105172	sqlite3VdbeAddOp2(v, OP_Null, 0, target);
105173	return target;
105174	}
105175	#ifndef SQLITE_OMIT_BLOB_LITERAL
105176	case TK_BLOB: {
	@@ -105509,11 +105562,12 @@
105509	case TK_SELECT_COLUMN: {
105510	int n;
105511	if( pExpr->pLeft->iTable==0 ){
105512	pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft);
105513	}
105514	assert( pExpr->iTable==0 \|\| pExpr->pLeft->op==TK_SELECT );

105515	if( pExpr->iTable!=0
105516	&& pExpr->iTable!=(n = sqlite3ExprVectorSize(pExpr->pLeft))
105517	){
105518	sqlite3ErrorMsg(pParse, "%d columns assigned %d values",
105519	pExpr->iTable, n);
	@@ -107141,10 +107195,11 @@
107141	/* Check to see if pExpr is a duplicate of another aggregate
107142	** function that is already in the pAggInfo structure
107143	*/
107144	struct AggInfo_func *pItem = pAggInfo->aFunc;
107145	for(i=0; i<pAggInfo->nFunc; i++, pItem++){

107146	if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
107147	break;
107148	}
107149	}
107150	if( i>=pAggInfo->nFunc ){
	@@ -108229,11 +108284,11 @@
108229	Parse *pParse,
108230	struct RenameCtx *pCtx,
108231	void *pPtr
108232	){
108233	RenameToken **pp;
108234	if( NEVER(pPtr==0) ){
108235	return 0;
108236	}
108237	for(pp=&pParse->pRename; (pp); pp=&(pp)->pNext){
108238	if( (*pp)->p==pPtr ){
108239	RenameToken pToken = pp;
	@@ -111886,18 +111941,21 @@
111886	SrcList *pList = pSelect->pSrc;
111887
111888	if( NEVER(pList==0) ) return WRC_Continue;
111889	for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
111890	if( pFix->bTemp==0 ){
111891	if( pItem->zDatabase && iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
111892	sqlite3ErrorMsg(pFix->pParse,
111893	"%s %T cannot reference objects in database %s",
111894	pFix->zType, pFix->pName, pItem->zDatabase);
111895	return WRC_Abort;
111896	}
111897	sqlite3DbFree(db, pItem->zDatabase);
111898	pItem->zDatabase = 0;



111899	pItem->pSchema = pFix->pSchema;
111900	pItem->fg.fromDDL = 1;
111901	}
111902	#if !defined(SQLITE_OMIT_VIEW) \|\| !defined(SQLITE_OMIT_TRIGGER)
111903	if( sqlite3WalkExpr(&pFix->w, pList->a[i].pOn) ) return WRC_Abort;
	@@ -113178,11 +113236,11 @@
113178	if( iDb<0 ){
113179	sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
113180	return -1;
113181	}
113182	}else{
113183	assert( db->init.iDb==0 \|\| db->init.busy \|\| IN_RENAME_OBJECT
113184	\|\| (db->mDbFlags & DBFLAG_Vacuum)!=0);
113185	iDb = db->init.iDb;
113186	*pUnqual = pName1;
113187	}
113188	return iDb;
	@@ -113360,10 +113418,11 @@
113360	static void sqlite3ForceNotReadOnly(Parse *pParse){
113361	int iReg = ++pParse->nMem;
113362	Vdbe *v = sqlite3GetVdbe(pParse);
113363	if( v ){
113364	sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY);

113365	}
113366	}
113367
113368	/*
113369	** Begin constructing a new table representation in memory. This is
	@@ -118643,10 +118702,13 @@
118643	pTab->zName, P4_STATIC);
118644	}
118645	for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
118646	assert( pIdx->pSchema==pTab->pSchema );
118647	sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);



118648	}
118649	}else
118650	#endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
118651	{
118652	u16 wcf = WHERE_ONEPASS_DESIRED\|WHERE_DUPLICATES_OK;
	@@ -133883,11 +133945,11 @@
133883	**
133884	** full=ON, short=ANY: If the result refers directly to a table column,
133885	** then the result column name with the table name
133886	** prefix, ex: TABLE.COLUMN. Otherwise use zSpan.
133887	*/
133888	static void generateColumnNames(
133889	Parse pParse, / Parser context */
133890	Select pSelect / Generate column names for this SELECT statement */
133891	){
133892	Vdbe *v = pParse->pVdbe;
133893	int i;
	@@ -133973,11 +134035,11 @@
133973	** That is the only documented guarantee. However, countless applications
133974	** developed over the years have made baseless assumptions about column names
133975	** and will break if those assumptions changes. Hence, use extreme caution
133976	** when modifying this routine to avoid breaking legacy.
133977	**
133978	** See Also: generateColumnNames()
133979	*/
133980	SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
133981	Parse pParse, / Parsing context */
133982	ExprList pEList, / Expr list from which to derive column names */
133983	i16 pnCol, / Write the number of columns here */
	@@ -134676,10 +134738,11 @@
134676	int nLimit = 0; /* Initialize to suppress harmless compiler warning */
134677	assert( !pPrior->pLimit );
134678	pPrior->iLimit = p->iLimit;
134679	pPrior->iOffset = p->iOffset;
134680	pPrior->pLimit = p->pLimit;

134681	rc = sqlite3Select(pParse, pPrior, &dest);
134682	pPrior->pLimit = 0;
134683	if( rc ){
134684	goto multi_select_end;
134685	}
	@@ -134693,10 +134756,11 @@
134693	sqlite3VdbeAddOp3(v, OP_OffsetLimit,
134694	p->iLimit, p->iOffset+1, p->iOffset);
134695	}
134696	}
134697	ExplainQueryPlan((pParse, 1, "UNION ALL"));

134698	rc = sqlite3Select(pParse, p, &dest);
134699	testcase( rc!=SQLITE_OK );
134700	pDelete = p->pPrior;
134701	p->pPrior = pPrior;
134702	p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
	@@ -134745,10 +134809,11 @@
134745
134746	/* Code the SELECT statements to our left
134747	*/
134748	assert( !pPrior->pOrderBy );
134749	sqlite3SelectDestInit(&uniondest, priorOp, unionTab);

134750	rc = sqlite3Select(pParse, pPrior, &uniondest);
134751	if( rc ){
134752	goto multi_select_end;
134753	}
134754
	@@ -134764,10 +134829,11 @@
134764	pLimit = p->pLimit;
134765	p->pLimit = 0;
134766	uniondest.eDest = op;
134767	ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
134768	sqlite3SelectOpName(p->op)));

134769	rc = sqlite3Select(pParse, p, &uniondest);
134770	testcase( rc!=SQLITE_OK );
134771	assert( p->pOrderBy==0 );
134772	pDelete = p->pPrior;
134773	p->pPrior = pPrior;
	@@ -134824,10 +134890,11 @@
134824	assert( p->pEList );
134825
134826	/* Code the SELECTs to our left into temporary table "tab1".
134827	*/
134828	sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);

134829	rc = sqlite3Select(pParse, pPrior, &intersectdest);
134830	if( rc ){
134831	goto multi_select_end;
134832	}
134833
	@@ -134840,10 +134907,11 @@
134840	pLimit = p->pLimit;
134841	p->pLimit = 0;
134842	intersectdest.iSDParm = tab2;
134843	ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
134844	sqlite3SelectOpName(p->op)));

134845	rc = sqlite3Select(pParse, p, &intersectdest);
134846	testcase( rc!=SQLITE_OK );
134847	pDelete = p->pPrior;
134848	p->pPrior = pPrior;
134849	if( p->nSelectRow>pPrior->nSelectRow ){
	@@ -136339,10 +136407,11 @@
136339	typedef struct WhereConst WhereConst;
136340	struct WhereConst {
136341	Parse pParse; / Parsing context */
136342	int nConst; /* Number for COLUMN=CONSTANT terms */
136343	int nChng; /* Number of times a constant is propagated */

136344	Expr *apExpr; / [i2] is COLUMN and [i2+1] is VALUE */
136345	};
136346
136347	/*
136348	** Add a new entry to the pConst object. Except, do not add duplicate
	@@ -136376,10 +136445,13 @@
136376	if( pE2->iTable==pColumn->iTable
136377	&& pE2->iColumn==pColumn->iColumn
136378	){
136379	return; /* Already present. Return without doing anything. */
136380	}



136381	}
136382
136383	pConst->nConst++;
136384	pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
136385	pConst->nConst2sizeof(Expr*));
	@@ -136418,30 +136490,38 @@
136418	constInsert(pConst,pLeft,pRight,pExpr);
136419	}
136420	}
136421
136422	/*
136423	** This is a Walker expression callback. pExpr is a candidate expression
136424	** to be replaced by a value. If pExpr is equivalent to one of the
136425	** columns named in pWalker->u.pConst, then overwrite it with its
136426	** corresponding value.



136427	*/
136428	static int propagateConstantExprRewrite(Walker pWalker, Expr pExpr){




136429	int i;
136430	WhereConst *pConst;
136431	if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
136432	if( ExprHasProperty(pExpr, EP_FixedCol\|EP_FromJoin) ){
136433	testcase( ExprHasProperty(pExpr, EP_FixedCol) );
136434	testcase( ExprHasProperty(pExpr, EP_FromJoin) );
136435	return WRC_Continue;
136436	}
136437	pConst = pWalker->u.pConst;
136438	for(i=0; i<pConst->nConst; i++){
136439	Expr pColumn = pConst->apExpr[i2];
136440	if( pColumn==pExpr ) continue;
136441	if( pColumn->iTable!=pExpr->iTable ) continue;
136442	if( pColumn->iColumn!=pExpr->iColumn ) continue;



136443	/* A match is found. Add the EP_FixedCol property */
136444	pConst->nChng++;
136445	ExprClearProperty(pExpr, EP_Leaf);
136446	ExprSetProperty(pExpr, EP_FixedCol);
136447	assert( pExpr->pLeft==0 );
	@@ -136448,10 +136528,45 @@
136448	pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
136449	break;
136450	}
136451	return WRC_Prune;
136452	}



































136453
136454	/*
136455	** The WHERE-clause constant propagation optimization.
136456	**
136457	** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
	@@ -136484,10 +136599,25 @@
136484	** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol
136485	** and the "123" value is hung off of the pLeft pointer. Code generator
136486	** routines know to generate the constant "123" instead of looking up the
136487	** column value. Also, to avoid collation problems, this optimization is
136488	** only attempted if the "a=123" term uses the default BINARY collation.















136489	*/
136490	static int propagateConstants(
136491	Parse pParse, / The parsing context */
136492	Select p / The query in which to propagate constants */
136493	){
	@@ -136497,10 +136627,11 @@
136497	x.pParse = pParse;
136498	do{
136499	x.nConst = 0;
136500	x.nChng = 0;
136501	x.apExpr = 0;

136502	findConstInWhere(&x, p->pWhere);
136503	if( x.nConst ){
136504	memset(&w, 0, sizeof(w));
136505	w.pParse = pParse;
136506	w.xExprCallback = propagateConstantExprRewrite;
	@@ -136933,29 +137064,32 @@
136933	if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
136934	*ppContext = p;
136935	return &p->a[i];
136936	}
136937	}

136938	}
136939	return 0;
136940	}
136941
136942	/* The code generator maintains a stack of active WITH clauses
136943	** with the inner-most WITH clause being at the top of the stack.
136944	**
136945	** This routine pushes the WITH clause passed as the second argument
136946	** onto the top of the stack. If argument bFree is true, then this
136947	** WITH clause will never be popped from the stack. In this case it
136948	** should be freed along with the Parse object. In other cases, when
136949	** bFree==0, the With object will be freed along with the SELECT
136950	** statement with which it is associated.
136951	*/
136952	SQLITE_PRIVATE void sqlite3WithPush(Parse pParse, With pWith, u8 bFree){
136953	if( pWith ){
136954	assert( pParse->pWith!=pWith );
136955	pWith->pOuter = pParse->pWith;
136956	pParse->pWith = pWith;


136957	if( bFree ){
136958	sqlite3ParserAddCleanup(pParse,
136959	(void()(sqlite3,void*))sqlite3WithDelete,
136960	pWith);
136961	testcase( pParse->earlyCleanup );
	@@ -136987,15 +137121,28 @@
136987
136988	assert( pFrom->pTab==0 );
136989	if( pParse->pWith==0 ){
136990	/* There are no WITH clauses in the stack. No match is possible */
136991	return 0;





136992	}
136993	if( pFrom->zDatabase!=0 ){
136994	/* The FROM term contains a schema qualifier (ex: main.t1) and so
136995	** it cannot possibly be a CTE reference. */
136996	return 0;








136997	}
136998	pCte = searchWith(pParse->pWith, pFrom, &pWith);
136999	if( pCte ){
137000	sqlite3 *db = pParse->db;
137001	Table *pTab;
	@@ -137237,10 +137384,19 @@
137237	/* Renumber selId because it has been copied from a view */
137238	p->selId = ++pParse->nSelect;
137239	}
137240	pTabList = p->pSrc;
137241	pEList = p->pEList;









137242	sqlite3WithPush(pParse, p->pWith, 0);
137243
137244	/* Make sure cursor numbers have been assigned to all entries in
137245	** the FROM clause of the SELECT statement.
137246	*/
	@@ -138124,11 +138280,11 @@
138124	}
138125	}
138126	}
138127
138128	if( pDest->eDest==SRT_Output ){
138129	generateColumnNames(pParse, p);
138130	}
138131
138132	#ifndef SQLITE_OMIT_WINDOWFUNC
138133	if( sqlite3WindowRewrite(pParse, p) ){
138134	assert( db->mallocFailed \|\| pParse->nErr>0 );
	@@ -138318,23 +138474,12 @@
138318	/* Generate code for all sub-queries in the FROM clause
138319	*/
138320	pSub = pItem->pSelect;
138321	if( pSub==0 ) continue;
138322
138323	/* The code for a subquery should only be generated once, though it is
138324	** technically harmless for it to be generated multiple times. The
138325	** following assert() will detect if something changes to cause
138326	** the same subquery to be coded multiple times, as a signal to the
138327	** developers to try to optimize the situation.
138328	**
138329	** Update 2019-07-24:
138330	** See ticket https://sqlite.org/src/tktview/c52b09c7f38903b1311cec40.
138331	** The dbsqlfuzz fuzzer found a case where the same subquery gets
138332	** coded twice. So this assert() now becomes a testcase(). It should
138333	** be very rare, though.
138334	*/
138335	testcase( pItem->addrFillSub!=0 );
138336
138337	/* Increment Parse.nHeight by the height of the largest expression
138338	** tree referred to by this, the parent select. The child select
138339	** may contain expression trees of at most
138340	** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
	@@ -138417,18 +138562,17 @@
138417	sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub);
138418	}
138419	sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
138420	pSub->nSelectRow = pPrior->pSelect->nSelectRow;
138421	}else{
138422	/* Materalize the view. If the view is not correlated, generate a
138423	** subroutine to do the materialization so that subsequent uses of
138424	** the same view can reuse the materialization. */
138425	int topAddr;
138426	int onceAddr = 0;
138427	int retAddr;
138428
138429	testcase( pItem->addrFillSub==0 ); /* Ticket c52b09c7f38903b1311 */
138430	pItem->regReturn = ++pParse->nMem;
138431	topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
138432	pItem->addrFillSub = topAddr+1;
138433	if( pItem->fg.isCorrelated==0 ){
138434	/* If the subquery is not correlated and if we are not inside of
	@@ -140327,19 +140471,10 @@
140327	pItem->zEName = sqlite3DbStrDup(db, pList->a[i].zEName);
140328	pItem->eEName = pList->a[i].eEName;
140329	}
140330	}
140331	}
140332	if( !db->mallocFailed ){
140333	Vdbe *v = pParse->pVdbe;
140334	assert( v!=0 );
140335	sqlite3VdbeSetNumCols(v, pNew->nExpr);
140336	for(i=0; i<pNew->nExpr; i++){
140337	sqlite3VdbeSetColName(v, i, COLNAME_NAME, pNew->a[i].zEName,
140338	SQLITE_TRANSIENT);
140339	}
140340	}
140341	return pNew;
140342	}
140343
140344	/*
140345	** Generate code for the RETURNING trigger. Unlike other triggers
	@@ -140351,17 +140486,31 @@
140351	Trigger pTrigger, / The trigger step that defines the RETURNING */
140352	Table pTab, / The table to code triggers from */
140353	int regIn /* The first in an array of registers */
140354	){
140355	Vdbe *v = pParse->pVdbe;

140356	ExprList *pNew;
140357	Returning *pReturning;


140358
140359	assert( v!=0 );
140360	assert( pParse->bReturning );
140361	pReturning = pParse->u1.pReturning;
140362	assert( pTrigger == &(pReturning->retTrig) );











140363	pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
140364	if( pNew ){
140365	NameContext sNC;
140366	memset(&sNC, 0, sizeof(sNC));
140367	if( pReturning->nRetCol==0 ){
	@@ -140378,17 +140527,18 @@
140378	int nCol = pNew->nExpr;
140379	int reg = pParse->nMem+1;
140380	pParse->nMem += nCol+2;
140381	pReturning->iRetReg = reg;
140382	for(i=0; i<nCol; i++){
140383	sqlite3ExprCodeFactorable(pParse, pNew->a[i].pExpr, reg+i);

140384	}
140385	sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, i, reg+i);
140386	sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1);
140387	sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1);
140388	}
140389	sqlite3ExprListDelete(pParse->db, pNew);
140390	pParse->eTriggerOp = 0;
140391	pParse->pTriggerTab = 0;
140392	}
140393	}
140394
	@@ -141067,10 +141217,11 @@
141067	pSrc = sqlite3SrcListDup(db, pTabList, 0);
141068	pWhere2 = sqlite3ExprDup(db, pWhere, 0);
141069
141070	assert( pTabList->nSrc>1 );
141071	if( pSrc ){

141072	pSrc->a[0].iCursor = -1;
141073	pSrc->a[0].pTab->nTabRef--;
141074	pSrc->a[0].pTab = 0;
141075	}
141076	if( pPk ){
	@@ -145593,11 +145744,11 @@
145593	if( r1!=regBase+j ){
145594	if( nReg==1 ){
145595	sqlite3ReleaseTempReg(pParse, regBase);
145596	regBase = r1;
145597	}else{
145598	sqlite3VdbeAddOp2(v, OP_SCopy, r1, regBase+j);
145599	}
145600	}
145601	if( pTerm->eOperator & WO_IN ){
145602	if( pTerm->pExpr->flags & EP_xIsSelect ){
145603	/* No affinity ever needs to be (or should be) applied to a value
	@@ -145610,11 +145761,11 @@
145610	Expr *pRight = pTerm->pExpr->pRight;
145611	if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){
145612	sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
145613	VdbeCoverage(v);
145614	}
145615	if( pParse->db->mallocFailed==0 ){
145616	if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){
145617	zAff[j] = SQLITE_AFF_BLOB;
145618	}
145619	if( sqlite3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){
145620	zAff[j] = SQLITE_AFF_BLOB;
	@@ -145959,11 +146110,11 @@
145959	for(i=0; i<nReg; i++){
145960	sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
145961	}
145962	}
145963	}else{
145964	assert( nReg==1 );
145965	sqlite3ExprCode(pParse, p, iReg);
145966	}
145967	}
145968
145969	/* An instance of the IdxExprTrans object carries information about a
	@@ -147007,11 +147158,11 @@
147007	}
147008	if( pAndExpr ){
147009	/* The extra 0x10000 bit on the opcode is masked off and does not
147010	** become part of the new Expr.op. However, it does make the
147011	** op==TK_AND comparison inside of sqlite3PExpr() false, and this
147012	** prevents sqlite3PExpr() from implementing AND short-circuit
147013	** optimization, which we do not want here. */
147014	pAndExpr = sqlite3PExpr(pParse, TK_AND\|0x10000, 0, pAndExpr);
147015	}
147016	}
147017
	@@ -147023,14 +147174,20 @@
147023	for(ii=0; ii<pOrWc->nTerm; ii++){
147024	WhereTerm *pOrTerm = &pOrWc->a[ii];
147025	if( pOrTerm->leftCursor==iCur \|\| (pOrTerm->eOperator & WO_AND)!=0 ){
147026	WhereInfo pSubWInfo; / Info for single OR-term scan */
147027	Expr pOrExpr = pOrTerm->pExpr; / Current OR clause term */

147028	int jmp1 = 0; /* Address of jump operation */
147029	testcase( (pTabItem[0].fg.jointype & JT_LEFT)!=0
147030	&& !ExprHasProperty(pOrExpr, EP_FromJoin)
147031	); /* See TH3 vtab25.400 and ticket 614b25314c766238 */





147032	if( pAndExpr ){
147033	pAndExpr->pLeft = pOrExpr;
147034	pOrExpr = pAndExpr;
147035	}
147036	/* Loop through table entries that match term pOrTerm. */
	@@ -147141,10 +147298,11 @@
147141
147142	/* Finish the loop through table entries that match term pOrTerm. */
147143	sqlite3WhereEnd(pSubWInfo);
147144	ExplainQueryPlanPop(pParse);
147145	}

147146	}
147147	}
147148	ExplainQueryPlanPop(pParse);
147149	pLevel->u.pCovidx = pCov;
147150	if( pCov ) pLevel->iIdxCur = iCovCur;
	@@ -151888,10 +152046,11 @@
151888	Expr *pExpr;
151889	pExpr = pTerm->pExpr;
151890	if( (!ExprHasProperty(pExpr, EP_FromJoin) \|\| pExpr->iRightJoinTable==iTab)
151891	&& (isLeft==0 \|\| ExprHasProperty(pExpr, EP_FromJoin))
151892	&& sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)

151893	){
151894	return 1;
151895	}
151896	}
151897	return 0;
	@@ -155605,11 +155764,11 @@
155605	** are invoked in the correct order as described under "SELECT REWRITING"
155606	** at the top of this file.
155607	*/
155608	SQLITE_PRIVATE int sqlite3WindowRewrite(Parse pParse, Select p){
155609	int rc = SQLITE_OK;
155610	if( p->pWin && p->pPrior==0 && (p->selFlags & SF_WinRewrite)==0 ){
155611	Vdbe *v = sqlite3GetVdbe(pParse);
155612	sqlite3 *db = pParse->db;
155613	Select pSub = 0; / The subquery */
155614	SrcList *pSrc = p->pSrc;
155615	Expr *pWhere = p->pWhere;
	@@ -155631,10 +155790,11 @@
155631	}
155632	sqlite3AggInfoPersistWalkerInit(&w, pParse);
155633	sqlite3WalkSelect(&w, p);
155634	if( (p->selFlags & SF_Aggregate)==0 ){
155635	w.xExprCallback = disallowAggregatesInOrderByCb;

155636	sqlite3WalkExprList(&w, p->pOrderBy);
155637	}
155638
155639	p->pSrc = 0;
155640	p->pWhere = 0;
	@@ -158141,12 +158301,13 @@
158141	#define TK_VECTOR 176
158142	#define TK_SELECT_COLUMN 177
158143	#define TK_IF_NULL_ROW 178
158144	#define TK_ASTERISK 179
158145	#define TK_SPAN 180
158146	#define TK_SPACE 181
158147	#define TK_ILLEGAL 182

158148	#endif
158149	/************** End token definitions *************************************/
158150
158151	/* The next sections is a series of control #defines.
158152	** various aspects of the generated parser.
	@@ -158202,33 +158363,33 @@
158202	#ifndef INTERFACE
158203	# define INTERFACE 1
158204	#endif
158205	/*********** Begin control #defines ***************************************/
158206	#define YYCODETYPE unsigned short int
158207	#define YYNOCODE 316
158208	#define YYACTIONTYPE unsigned short int
158209	#define YYWILDCARD 101
158210	#define sqlite3ParserTOKENTYPE Token
158211	typedef union {
158212	int yyinit;
158213	sqlite3ParserTOKENTYPE yy0;
158214	Window* yy19;
158215	struct TrigEvent yy50;
158216	int yy60;
158217	struct FrameBound yy113;
158218	Upsert* yy178;
158219	With* yy195;
158220	IdList* yy288;
158221	SrcList* yy291;
158222	Select* yy307;
158223	ExprList* yy338;
158224	TriggerStep* yy483;
158225	const char* yy528;
158226	u8 yy570;
158227	Expr* yy602;
158228	Cte* yy607;
158229	struct {int value; int mask;} yy615;
158230	} YYMINORTYPE;
158231	#ifndef YYSTACKDEPTH
158232	#define YYSTACKDEPTH 100
158233	#endif
158234	#define sqlite3ParserARG_SDECL
	@@ -158243,11 +158404,11 @@
158243	#define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
158244	#define YYFALLBACK 1
158245	#define YYNSTATE 570
158246	#define YYNRULE 398
158247	#define YYNRULE_WITH_ACTION 337
158248	#define YYNTOKEN 183
158249	#define YY_MAX_SHIFT 569
158250	#define YY_MIN_SHIFTREDUCE 825
158251	#define YY_MAX_SHIFTREDUCE 1222
158252	#define YY_ERROR_ACTION 1223
158253	#define YY_ACCEPT_ACTION 1224
	@@ -158318,545 +158479,546 @@
158318	** yy_reduce_ofst[] For each state, the offset into yy_action for
158319	** shifting non-terminals after a reduce.
158320	** yy_default[] Default action for each state.
158321	**
158322	********* Begin parsing tables ********************************************/
158323	#define YY_ACTTAB_COUNT (2020)
158324	static const YYACTIONTYPE yy_action[] = {
158325	/* 0 */ 563, 1295, 563, 1274, 168, 361, 115, 112, 218, 373,
158326	/* 10 */ 563, 1295, 374, 563, 488, 563, 115, 112, 218, 406,
158327	/* 20 */ 1300, 1300, 41, 41, 41, 41, 514, 1504, 520, 1298,
158328	/* 30 */ 1298, 959, 41, 41, 1257, 71, 71, 51, 51, 960,
158329	/* 40 */ 557, 557, 557, 122, 123, 113, 1200, 1200, 1035, 1038,
158330	/* 50 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 414, 406,
158331	/* 60 */ 273, 273, 273, 273, 115, 112, 218, 115, 112, 218,
158332	/* 70 */ 197, 268, 545, 560, 515, 560, 1260, 563, 385, 248,
158333	/* 80 */ 215, 521, 399, 122, 123, 113, 1200, 1200, 1035, 1038,
158334	/* 90 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 540, 13,
158335	/* 100 */ 13, 1259, 119, 119, 119, 119, 118, 118, 117, 117,
158336	/* 110 */ 117, 116, 441, 1176, 419, 1531, 446, 137, 512, 1539,
158337	/* 120 */ 1545, 372, 1547, 6, 371, 1176, 1148, 1584, 1148, 406,
158338	/* 130 */ 1545, 534, 115, 112, 218, 1267, 99, 441, 121, 121,
158339	/* 140 */ 121, 121, 119, 119, 119, 119, 118, 118, 117, 117,
158340	/* 150 */ 117, 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038,
158341	/* 160 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 197, 1176,
158342	/* 170 */ 1177, 1178, 241, 304, 554, 501, 498, 497, 473, 124,
158343	/* 180 */ 394, 1176, 1177, 1178, 1176, 496, 119, 119, 119, 119,
158344	/* 190 */ 118, 118, 117, 117, 117, 116, 441, 139, 540, 406,
158345	/* 200 */ 121, 121, 121, 121, 114, 117, 117, 117, 116, 441,
158346	/* 210 */ 541, 1532, 119, 119, 119, 119, 118, 118, 117, 117,
158347	/* 220 */ 117, 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038,
158348	/* 230 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 406, 320,
158349	/* 240 */ 1176, 1177, 1178, 81, 342, 1590, 396, 80, 119, 119,
158350	/* 250 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 1176,
158351	/* 260 */ 211, 450, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158352	/* 270 */ 1028, 120, 120, 121, 121, 121, 121, 251, 450, 449,
158353	/* 280 */ 273, 273, 119, 119, 119, 119, 118, 118, 117, 117,
158354	/* 290 */ 117, 116, 441, 560, 1224, 1, 1, 569, 2, 1228,
158355	/* 300 */ 317, 1176, 319, 1561, 305, 337, 140, 340, 406, 430,
158356	/* 310 */ 469, 1533, 1197, 1308, 348, 1176, 1177, 1178, 168, 462,
158357	/* 320 */ 330, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158358	/* 330 */ 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158359	/* 340 */ 1028, 120, 120, 121, 121, 121, 121, 273, 273, 563,
158360	/* 350 */ 83, 450, 416, 1564, 569, 2, 1228, 1176, 1177, 1178,
158361	/* 360 */ 560, 305, 471, 140, 944, 995, 860, 563, 467, 1197,
158362	/* 370 */ 1308, 13, 13, 137, 229, 118, 118, 117, 117, 117,
158363	/* 380 */ 116, 441, 96, 318, 946, 504, 424, 361, 562, 71,
158364	/* 390 */ 71, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158365	/* 400 */ 116, 441, 427, 205, 273, 273, 445, 1015, 259, 276,
158366	/* 410 */ 356, 507, 351, 506, 246, 406, 959, 560, 328, 344,
158367	/* 420 */ 347, 315, 860, 1006, 960, 126, 545, 1005, 313, 304,
158368	/* 430 */ 554, 229, 538, 1539, 148, 544, 281, 6, 203, 122,
158369	/* 440 */ 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120,
158370	/* 450 */ 121, 121, 121, 121, 563, 217, 563, 12, 406, 1005,
158371	/* 460 */ 1005, 1007, 502, 445, 119, 119, 119, 119, 118, 118,
158372	/* 470 */ 117, 117, 117, 116, 441, 452, 71, 71, 70, 70,
158373	/* 480 */ 944, 137, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158374	/* 490 */ 1028, 120, 120, 121, 121, 121, 121, 1530, 119, 119,
158375	/* 500 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 403,
158376	/* 510 */ 402, 241, 1176, 545, 501, 498, 497, 1468, 1143, 451,
158377	/* 520 */ 267, 267, 513, 1540, 496, 142, 1176, 6, 406, 530,
158378	/* 530 */ 194, 1143, 864, 560, 1143, 461, 182, 304, 554, 32,
158379	/* 540 */ 379, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158380	/* 550 */ 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158381	/* 560 */ 1028, 120, 120, 121, 121, 121, 121, 406, 1176, 1177,
158382	/* 570 */ 1178, 857, 568, 1176, 1228, 925, 1176, 454, 361, 305,
158383	/* 580 */ 189, 140, 1176, 1177, 1178, 519, 529, 404, 1308, 183,
158384	/* 590 */ 1015, 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
158385	/* 600 */ 120, 120, 121, 121, 121, 121, 1006, 16, 16, 370,
158386	/* 610 */ 1005, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158387	/* 620 */ 116, 441, 273, 273, 1537, 150, 1176, 98, 6, 1176,
158388	/* 630 */ 1177, 1178, 1176, 1177, 1178, 560, 380, 406, 376, 438,
158389	/* 640 */ 437, 1161, 1005, 1005, 1007, 1025, 1025, 1036, 1039, 229,
158390	/* 650 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116,
158391	/* 660 */ 441, 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
158392	/* 670 */ 120, 120, 121, 121, 121, 121, 406, 1143, 1619, 392,
158393	/* 680 */ 1016, 445, 1176, 1177, 1178, 1207, 525, 1207, 1530, 995,
158394	/* 690 */ 1143, 304, 554, 1143, 5, 563, 543, 3, 361, 216,
158395	/* 700 */ 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120,
158396	/* 710 */ 120, 121, 121, 121, 121, 143, 563, 13, 13, 1029,
158397	/* 720 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116,
158398	/* 730 */ 441, 1176, 426, 563, 1176, 563, 274, 274, 13, 13,
158399	/* 740 */ 1078, 1176, 328, 457, 316, 147, 406, 211, 361, 560,
158400	/* 750 */ 1000, 213, 511, 293, 477, 55, 55, 71, 71, 119,
158401	/* 760 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 441,
158402	/* 770 */ 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120,
158403	/* 780 */ 120, 121, 121, 121, 121, 406, 455, 1176, 1177, 1178,
158404	/* 790 */ 1176, 1177, 1178, 471, 526, 149, 404, 1176, 1177, 1178,
158405	/* 800 */ 105, 270, 103, 563, 944, 563, 116, 441, 1530, 122,
158406	/* 810 */ 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120,
158407	/* 820 */ 121, 121, 121, 121, 945, 13, 13, 13, 13, 119,
158408	/* 830 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 441,
158409	/* 840 */ 191, 563, 192, 563, 416, 439, 439, 439, 1083, 1083,
158410	/* 850 */ 485, 561, 285, 914, 914, 406, 462, 330, 1530, 830,
158411	/* 860 */ 831, 832, 206, 71, 71, 71, 71, 286, 119, 119,
158412	/* 870 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 122,
158413	/* 880 */ 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120,
158414	/* 890 */ 121, 121, 121, 121, 563, 217, 563, 1122, 1617, 406,
158415	/* 900 */ 300, 1617, 301, 416, 1278, 1473, 244, 243, 242, 1249,
158416	/* 910 */ 412, 556, 412, 282, 842, 279, 71, 71, 71, 71,
158417	/* 920 */ 944, 1415, 1473, 1475, 101, 113, 1200, 1200, 1035, 1038,
158418	/* 930 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 119, 119,
158419	/* 940 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 273,
158420	/* 950 */ 273, 1099, 563, 436, 1143, 440, 563, 1122, 1618, 357,
158421	/* 960 */ 1558, 1618, 560, 546, 488, 197, 1100, 1143, 378, 290,
158422	/* 970 */ 1143, 1306, 284, 460, 71, 71, 1120, 405, 13, 13,
158423	/* 980 */ 145, 1101, 119, 119, 119, 119, 118, 118, 117, 117,
158424	/* 990 */ 117, 116, 441, 542, 104, 1473, 509, 273, 273, 294,
158425	/* 1000 */ 1514, 294, 900, 273, 273, 273, 273, 563, 1503, 563,
158426	/* 1010 */ 560, 545, 901, 464, 406, 1058, 560, 852, 560, 198,
158427	/* 1020 */ 547, 1080, 920, 404, 1400, 1080, 146, 919, 38, 56,
158428	/* 1030 */ 56, 15, 15, 563, 406, 12, 1120, 471, 122, 123,
158429	/* 1040 */ 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120, 121,
158430	/* 1050 */ 121, 121, 121, 1460, 406, 43, 43, 483, 122, 123,
158431	/* 1060 */ 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120, 121,
158432	/* 1070 */ 121, 121, 121, 563, 852, 9, 471, 251, 122, 111,
158433	/* 1080 */ 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120, 121,
158434	/* 1090 */ 121, 121, 121, 563, 421, 57, 57, 119, 119, 119,
158435	/* 1100 */ 119, 118, 118, 117, 117, 117, 116, 441, 1176, 493,
158436	/* 1110 */ 563, 289, 1197, 478, 1516, 44, 44, 119, 119, 119,
158437	/* 1120 */ 119, 118, 118, 117, 117, 117, 116, 441, 880, 563,
158438	/* 1130 */ 536, 563, 58, 58, 488, 1414, 245, 119, 119, 119,
158439	/* 1140 */ 119, 118, 118, 117, 117, 117, 116, 441, 563, 535,
158440	/* 1150 */ 291, 59, 59, 60, 60, 438, 437, 406, 1154, 505,
158441	/* 1160 */ 304, 554, 477, 1204, 1176, 1177, 1178, 881, 1206, 1197,
158442	/* 1170 */ 61, 61, 1246, 357, 1558, 1538, 1205, 563, 1467, 6,
158443	/* 1180 */ 1176, 488, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
158444	/* 1190 */ 120, 120, 121, 121, 121, 121, 1400, 1143, 410, 62,
158445	/* 1200 */ 62, 1207, 1099, 1207, 411, 447, 273, 273, 537, 1154,
158446	/* 1210 */ 1143, 108, 555, 1143, 4, 391, 1220, 1100, 1512, 560,
158447	/* 1220 */ 347, 516, 428, 548, 308, 1307, 1536, 1077, 558, 1077,
158448	/* 1230 */ 6, 488, 1101, 1400, 488, 309, 1176, 1177, 1178, 563,
158449	/* 1240 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116,
158450	/* 1250 */ 441, 442, 278, 551, 563, 273, 273, 273, 273, 563,
158451	/* 1260 */ 327, 45, 45, 552, 563, 528, 422, 563, 560, 1400,
158452	/* 1270 */ 560, 108, 555, 137, 4, 1303, 46, 46, 335, 563,
158453	/* 1280 */ 482, 47, 47, 477, 479, 307, 49, 49, 558, 50,
158454	/* 1290 */ 50, 563, 1015, 563, 1221, 563, 1400, 563, 106, 106,
158455	/* 1300 */ 8, 63, 63, 423, 563, 107, 312, 442, 565, 564,
158456	/* 1310 */ 563, 442, 1005, 64, 64, 65, 65, 14, 14, 66,
158457	/* 1320 */ 66, 391, 1121, 552, 1312, 1180, 128, 128, 563, 304,
158458	/* 1330 */ 554, 563, 67, 67, 563, 359, 560, 532, 563, 484,
158459	/* 1340 */ 563, 1196, 531, 222, 1005, 1005, 1007, 1008, 27, 522,
158460	/* 1350 */ 52, 52, 1015, 68, 68, 563, 69, 69, 106, 106,
158461	/* 1360 */ 53, 53, 156, 156, 563, 107, 434, 442, 565, 564,
158462	/* 1370 */ 272, 215, 1005, 425, 563, 359, 563, 157, 157, 563,
158463	/* 1380 */ 1535, 292, 1180, 98, 6, 1344, 76, 76, 1215, 475,
158464	/* 1390 */ 413, 169, 226, 563, 245, 563, 54, 54, 72, 72,
158465	/* 1400 */ 1221, 129, 129, 1343, 1005, 1005, 1007, 1008, 27, 1563,
158466	/* 1410 */ 1165, 444, 456, 433, 277, 73, 73, 130, 130, 389,
158467	/* 1420 */ 389, 388, 262, 386, 1165, 444, 839, 1519, 277, 108,
158468	/* 1430 */ 555, 321, 4, 389, 389, 388, 262, 386, 563, 223,
158469	/* 1440 */ 839, 311, 468, 84, 202, 523, 558, 1492, 303, 310,
158470	/* 1450 */ 563, 110, 404, 223, 563, 311, 206, 30, 404, 277,
158471	/* 1460 */ 131, 131, 411, 310, 389, 389, 388, 262, 386, 442,
158472	/* 1470 */ 920, 839, 127, 127, 563, 919, 155, 155, 1491, 225,
158473	/* 1480 */ 563, 552, 871, 563, 223, 476, 311, 161, 31, 563,
158474	/* 1490 */ 135, 563, 480, 225, 310, 532, 154, 154, 332, 17,
158475	/* 1500 */ 533, 161, 136, 136, 135, 134, 134, 224, 228, 355,
158476	/* 1510 */ 1015, 132, 132, 133, 133, 1589, 106, 106, 889, 354,
158477	/* 1520 */ 563, 224, 563, 107, 225, 442, 565, 564, 1117, 275,
158478	/* 1530 */ 1005, 393, 161, 518, 563, 135, 108, 555, 417, 4,
158479	/* 1540 */ 1340, 407, 75, 75, 77, 77, 304, 554, 867, 563,
158480	/* 1550 */ 336, 563, 224, 558, 463, 407, 74, 74, 465, 1065,
158481	/* 1560 */ 304, 554, 1005, 1005, 1007, 1008, 27, 962, 963, 543,
158482	/* 1570 */ 448, 42, 42, 48, 48, 326, 442, 325, 98, 997,
158483	/* 1580 */ 470, 287, 250, 250, 448, 1009, 407, 472, 552, 339,
158484	/* 1590 */ 250, 304, 554, 879, 878, 331, 108, 555, 98, 4,
158485	/* 1600 */ 1277, 494, 532, 345, 247, 867, 98, 531, 341, 886,
158486	/* 1610 */ 887, 1126, 1076, 558, 1076, 448, 1065, 1015, 1061, 953,
158487	/* 1620 */ 343, 247, 250, 106, 106, 1291, 917, 1276, 850, 110,
158488	/* 1630 */ 107, 144, 442, 565, 564, 918, 442, 1005, 110, 1275,
158489	/* 1640 */ 350, 360, 1009, 1331, 1352, 299, 1399, 1577, 552, 1327,
158490	/* 1650 */ 1552, 550, 1338, 549, 1405, 1256, 1248, 1237, 1236, 1238,
158491	/* 1660 */ 1571, 489, 265, 200, 1324, 363, 365, 367, 11, 1005,
158492	/* 1670 */ 1005, 1007, 1008, 27, 390, 221, 1386, 1015, 280, 1391,
158493	/* 1680 */ 1381, 208, 323, 106, 106, 924, 1374, 453, 283, 324,
158494	/* 1690 */ 107, 474, 442, 565, 564, 1390, 499, 1005, 212, 288,
158495	/* 1700 */ 1274, 397, 353, 108, 555, 195, 4, 1464, 369, 1463,
158496	/* 1710 */ 1574, 1215, 1212, 329, 553, 171, 207, 383, 1511, 196,
158497	/* 1720 */ 558, 254, 1509, 415, 100, 555, 83, 4, 204, 1005,
158498	/* 1730 */ 1005, 1007, 1008, 27, 219, 79, 82, 1469, 180, 166,
158499	/* 1740 */ 173, 558, 458, 442, 175, 176, 177, 178, 35, 1387,
158500	/* 1750 */ 492, 459, 231, 1395, 96, 552, 1393, 1392, 395, 184,
158501	/* 1760 */ 481, 466, 36, 235, 442, 89, 398, 266, 487, 1480,
158502	/* 1770 */ 1458, 237, 188, 338, 508, 429, 552, 490, 400, 238,
158503	/* 1780 */ 334, 1239, 239, 1294, 1015, 1293, 1292, 1285, 91, 871,
158504	/* 1790 */ 106, 106, 213, 431, 1588, 432, 524, 107, 517, 442,
158505	/* 1800 */ 565, 564, 401, 1264, 1005, 1015, 1263, 1587, 352, 1262,
158506	/* 1810 */ 1557, 106, 106, 1586, 1284, 297, 298, 358, 107, 1335,
158507	/* 1820 */ 442, 565, 564, 95, 362, 1005, 253, 252, 435, 125,
158508	/* 1830 */ 543, 10, 1444, 1543, 377, 1542, 1005, 1005, 1007, 1008,
158509	/* 1840 */ 27, 302, 102, 97, 527, 1336, 260, 1317, 364, 1245,
158510	/* 1850 */ 1334, 34, 566, 1171, 366, 381, 375, 1005, 1005, 1007,
158511	/* 1860 */ 1008, 27, 1333, 1359, 368, 1316, 199, 382, 261, 263,
158512	/* 1870 */ 264, 1358, 158, 1496, 141, 1497, 1495, 567, 1234, 1229,
158513	/* 1880 */ 1494, 295, 159, 209, 210, 78, 826, 443, 201, 306,
158514	/* 1890 */ 220, 1075, 138, 1073, 160, 314, 162, 172, 1196, 174,
158515	/* 1900 */ 903, 227, 230, 322, 1089, 179, 163, 164, 418, 85,
158516	/* 1910 */ 420, 181, 170, 408, 409, 86, 87, 165, 88, 1092,
158517	/* 1920 */ 232, 233, 1088, 151, 18, 234, 1081, 250, 333, 185,
158518	/* 1930 */ 1209, 486, 236, 186, 37, 841, 491, 354, 240, 346,
158519	/* 1940 */ 503, 187, 90, 167, 19, 495, 20, 869, 500, 349,
158520	/* 1950 */ 92, 882, 296, 152, 93, 510, 1127, 1159, 153, 1041,
158521	/* 1960 */ 214, 1128, 39, 94, 269, 271, 952, 190, 947, 110,
158522	/* 1970 */ 1149, 1145, 1153, 249, 1133, 1147, 7, 33, 21, 193,
158523	/* 1980 */ 22, 23, 24, 25, 1152, 539, 98, 1056, 26, 1042,
158524	/* 1990 */ 1040, 1044, 1098, 1045, 1097, 256, 255, 28, 40, 387,
158525	/* 2000 */ 1010, 851, 109, 29, 1167, 559, 384, 257, 913, 258,
158526	/* 2010 */ 1166, 1579, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1578,

158527	};
158528	static const YYCODETYPE yy_lookahead[] = {
158529	/* 0 */ 191, 220, 191, 222, 191, 191, 271, 272, 273, 216,
158530	/* 10 */ 191, 230, 216, 191, 191, 191, 271, 272, 273, 19,
158531	/* 20 */ 232, 233, 213, 214, 213, 214, 202, 292, 202, 232,
158532	/* 30 */ 233, 31, 213, 214, 213, 213, 214, 213, 214, 39,
158533	/* 40 */ 207, 208, 209, 43, 44, 45, 46, 47, 48, 49,
158534	/* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 235, 19,
158535	/* 60 */ 236, 237, 236, 237, 271, 272, 273, 271, 272, 273,
158536	/* 70 */ 191, 210, 250, 249, 250, 249, 213, 191, 199, 253,
158537	/* 80 */ 254, 259, 203, 43, 44, 45, 46, 47, 48, 49,
158538	/* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 191, 213,
158539	/* 100 */ 214, 213, 102, 103, 104, 105, 106, 107, 108, 109,
158540	/* 110 */ 110, 111, 112, 59, 228, 301, 293, 81, 305, 306,
158541	/* 120 */ 311, 312, 311, 310, 313, 59, 86, 212, 88, 19,
158542	/* 130 */ 311, 312, 271, 272, 273, 220, 26, 112, 54, 55,
158543	/* 140 */ 56, 57, 102, 103, 104, 105, 106, 107, 108, 109,
158544	/* 150 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49,
158545	/* 160 */ 50, 51, 52, 53, 54, 55, 56, 57, 191, 115,
158546	/* 170 */ 116, 117, 118, 137, 138, 121, 122, 123, 191, 69,
158547	/* 180 */ 203, 115, 116, 117, 59, 131, 102, 103, 104, 105,
158548	/* 190 */ 106, 107, 108, 109, 110, 111, 112, 72, 191, 19,
158549	/* 200 */ 54, 55, 56, 57, 58, 108, 109, 110, 111, 112,
158550	/* 210 */ 303, 304, 102, 103, 104, 105, 106, 107, 108, 109,
158551	/* 220 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49,
158552	/* 230 */ 50, 51, 52, 53, 54, 55, 56, 57, 19, 16,
158553	/* 240 */ 115, 116, 117, 24, 16, 227, 202, 67, 102, 103,
158554	/* 250 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 59,
158555	/* 260 */ 26, 191, 43, 44, 45, 46, 47, 48, 49, 50,
158556	/* 270 */ 51, 52, 53, 54, 55, 56, 57, 24, 208, 209,
158557	/* 280 */ 236, 237, 102, 103, 104, 105, 106, 107, 108, 109,
158558	/* 290 */ 110, 111, 112, 249, 183, 184, 185, 186, 187, 188,
158559	/* 300 */ 77, 59, 79, 191, 193, 77, 195, 79, 19, 19,
158560	/* 310 */ 266, 304, 59, 202, 24, 115, 116, 117, 191, 127,
158561	/* 320 */ 128, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158562	/* 330 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50,
158563	/* 340 */ 51, 52, 53, 54, 55, 56, 57, 236, 237, 191,
158564	/* 350 */ 150, 281, 191, 185, 186, 187, 188, 115, 116, 117,
158565	/* 360 */ 249, 193, 191, 195, 26, 73, 59, 191, 114, 116,
158566	/* 370 */ 202, 213, 214, 81, 263, 106, 107, 108, 109, 110,
158567	/* 380 */ 111, 112, 148, 160, 142, 95, 228, 191, 191, 213,
158568	/* 390 */ 214, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158569	/* 400 */ 111, 112, 112, 149, 236, 237, 295, 100, 118, 119,
158570	/* 410 */ 120, 121, 122, 123, 124, 19, 31, 249, 126, 23,
158571	/* 420 */ 130, 260, 115, 116, 39, 22, 250, 120, 191, 137,
158572	/* 430 */ 138, 263, 305, 306, 238, 259, 265, 310, 149, 43,
158573	/* 440 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
158574	/* 450 */ 54, 55, 56, 57, 191, 117, 191, 210, 19, 152,
158575	/* 460 */ 153, 154, 23, 295, 102, 103, 104, 105, 106, 107,
158576	/* 470 */ 108, 109, 110, 111, 112, 266, 213, 214, 213, 214,
158577	/* 480 */ 142, 81, 43, 44, 45, 46, 47, 48, 49, 50,
158578	/* 490 */ 51, 52, 53, 54, 55, 56, 57, 301, 102, 103,
158579	/* 500 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 106,
158580	/* 510 */ 107, 118, 59, 250, 121, 122, 123, 280, 76, 119,
158581	/* 520 */ 236, 237, 259, 306, 131, 72, 59, 310, 19, 87,
158582	/* 530 */ 283, 89, 23, 249, 92, 288, 22, 137, 138, 22,
158583	/* 540 */ 275, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158584	/* 550 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50,
158585	/* 560 */ 51, 52, 53, 54, 55, 56, 57, 19, 115, 116,
158586	/* 570 */ 117, 23, 186, 59, 188, 108, 59, 241, 191, 193,
158587	/* 580 */ 26, 195, 115, 116, 117, 191, 144, 251, 202, 22,
158588	/* 590 */ 100, 43, 44, 45, 46, 47, 48, 49, 50, 51,
158589	/* 600 */ 52, 53, 54, 55, 56, 57, 116, 213, 214, 191,
158590	/* 610 */ 120, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158591	/* 620 */ 111, 112, 236, 237, 306, 238, 59, 26, 310, 115,
158592	/* 630 */ 116, 117, 115, 116, 117, 249, 246, 19, 248, 106,
158593	/* 640 */ 107, 23, 152, 153, 154, 46, 47, 48, 49, 263,
158594	/* 650 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
158595	/* 660 */ 112, 43, 44, 45, 46, 47, 48, 49, 50, 51,
158596	/* 670 */ 52, 53, 54, 55, 56, 57, 19, 76, 298, 299,
158597	/* 680 */ 23, 295, 115, 116, 117, 152, 191, 154, 301, 73,
158598	/* 690 */ 89, 137, 138, 92, 22, 191, 144, 22, 191, 191,
158599	/* 700 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
158600	/* 710 */ 53, 54, 55, 56, 57, 163, 191, 213, 214, 120,
158601	/* 720 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
158602	/* 730 */ 112, 59, 228, 191, 59, 191, 236, 237, 213, 214,
158603	/* 740 */ 11, 59, 126, 127, 128, 238, 19, 26, 191, 249,
158604	/* 750 */ 23, 164, 165, 228, 191, 213, 214, 213, 214, 102,
158605	/* 760 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
158606	/* 770 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
158607	/* 780 */ 53, 54, 55, 56, 57, 19, 241, 115, 116, 117,
158608	/* 790 */ 115, 116, 117, 191, 250, 238, 251, 115, 116, 117,
158609	/* 800 */ 157, 23, 159, 191, 26, 191, 111, 112, 301, 43,
158610	/* 810 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
158611	/* 820 */ 54, 55, 56, 57, 142, 213, 214, 213, 214, 102,
158612	/* 830 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
158613	/* 840 */ 228, 191, 228, 191, 191, 207, 208, 209, 126, 127,
158614	/* 850 */ 128, 133, 289, 135, 136, 19, 127, 128, 301, 7,
158615	/* 860 */ 8, 9, 141, 213, 214, 213, 214, 265, 102, 103,
158616	/* 870 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 43,
158617	/* 880 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
158618	/* 890 */ 54, 55, 56, 57, 191, 117, 191, 22, 23, 19,
158619	/* 900 */ 250, 26, 250, 191, 223, 191, 126, 127, 128, 205,
158620	/* 910 */ 206, 205, 206, 260, 21, 202, 213, 214, 213, 214,
158621	/* 920 */ 142, 270, 208, 209, 158, 45, 46, 47, 48, 49,
158622	/* 930 */ 50, 51, 52, 53, 54, 55, 56, 57, 102, 103,
158623	/* 940 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 236,
158624	/* 950 */ 237, 12, 191, 250, 76, 250, 191, 22, 23, 308,
158625	/* 960 */ 309, 26, 249, 202, 191, 191, 27, 89, 191, 202,
158626	/* 970 */ 92, 202, 260, 80, 213, 214, 101, 203, 213, 214,
158627	/* 980 */ 22, 42, 102, 103, 104, 105, 106, 107, 108, 109,
158628	/* 990 */ 110, 111, 112, 228, 158, 281, 108, 236, 237, 225,
158629	/* 1000 */ 191, 227, 63, 236, 237, 236, 237, 191, 235, 191,
158630	/* 1010 */ 249, 250, 73, 241, 19, 122, 249, 59, 249, 24,
158631	/* 1020 */ 259, 29, 134, 251, 191, 33, 22, 139, 24, 213,
158632	/* 1030 */ 214, 213, 214, 191, 19, 210, 101, 191, 43, 44,
158633	/* 1040 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
158634	/* 1050 */ 55, 56, 57, 160, 19, 213, 214, 65, 43, 44,
158635	/* 1060 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
158636	/* 1070 */ 55, 56, 57, 191, 116, 22, 191, 24, 43, 44,
158637	/* 1080 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
158638	/* 1090 */ 55, 56, 57, 191, 261, 213, 214, 102, 103, 104,
158639	/* 1100 */ 105, 106, 107, 108, 109, 110, 111, 112, 59, 19,
158640	/* 1110 */ 191, 265, 59, 288, 191, 213, 214, 102, 103, 104,
158641	/* 1120 */ 105, 106, 107, 108, 109, 110, 111, 112, 35, 191,
158642	/* 1130 */ 66, 191, 213, 214, 191, 270, 46, 102, 103, 104,
158643	/* 1140 */ 105, 106, 107, 108, 109, 110, 111, 112, 191, 85,
158644	/* 1150 */ 265, 213, 214, 213, 214, 106, 107, 19, 94, 66,
158645	/* 1160 */ 137, 138, 191, 114, 115, 116, 117, 74, 119, 116,
158646	/* 1170 */ 213, 214, 202, 308, 309, 306, 127, 191, 235, 310,
158647	/* 1180 */ 59, 191, 44, 45, 46, 47, 48, 49, 50, 51,
158648	/* 1190 */ 52, 53, 54, 55, 56, 57, 191, 76, 196, 213,
158649	/* 1200 */ 214, 152, 12, 154, 114, 191, 236, 237, 87, 145,
158650	/* 1210 */ 89, 19, 20, 92, 22, 22, 23, 27, 191, 249,
158651	/* 1220 */ 130, 202, 129, 202, 191, 235, 306, 152, 36, 154,
158652	/* 1230 */ 310, 191, 42, 191, 191, 191, 115, 116, 117, 191,
158653	/* 1240 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
158654	/* 1250 */ 112, 59, 99, 63, 191, 236, 237, 236, 237, 191,
158655	/* 1260 */ 289, 213, 214, 71, 191, 144, 261, 191, 249, 191,
158656	/* 1270 */ 249, 19, 20, 81, 22, 235, 213, 214, 235, 191,
158657	/* 1280 */ 278, 213, 214, 191, 282, 132, 213, 214, 36, 213,
158658	/* 1290 */ 214, 191, 100, 191, 101, 191, 191, 191, 106, 107,
158659	/* 1300 */ 48, 213, 214, 261, 191, 113, 191, 115, 116, 117,
158660	/* 1310 */ 191, 59, 120, 213, 214, 213, 214, 213, 214, 213,
158661	/* 1320 */ 214, 22, 23, 71, 237, 59, 213, 214, 191, 137,
158662	/* 1330 */ 138, 191, 213, 214, 191, 191, 249, 85, 191, 261,
158663	/* 1340 */ 191, 26, 90, 15, 152, 153, 154, 155, 156, 19,
158664	/* 1350 */ 213, 214, 100, 213, 214, 191, 213, 214, 106, 107,
158665	/* 1360 */ 213, 214, 213, 214, 191, 113, 261, 115, 116, 117,
158666	/* 1370 */ 253, 254, 120, 229, 191, 191, 191, 213, 214, 191,
158667	/* 1380 */ 306, 289, 116, 26, 310, 191, 213, 214, 60, 19,
158668	/* 1390 */ 296, 297, 24, 191, 46, 191, 213, 214, 213, 214,
158669	/* 1400 */ 101, 213, 214, 191, 152, 153, 154, 155, 156, 0,
158670	/* 1410 */ 1, 2, 191, 229, 5, 213, 214, 213, 214, 10,
158671	/* 1420 */ 11, 12, 13, 14, 1, 2, 17, 191, 5, 19,
158672	/* 1430 */ 20, 191, 22, 10, 11, 12, 13, 14, 191, 30,
158673	/* 1440 */ 17, 32, 241, 148, 149, 115, 36, 191, 241, 40,
158674	/* 1450 */ 191, 26, 251, 30, 191, 32, 141, 22, 251, 5,
158675	/* 1460 */ 213, 214, 114, 40, 10, 11, 12, 13, 14, 59,
158676	/* 1470 */ 134, 17, 213, 214, 191, 139, 213, 214, 191, 70,
158677	/* 1480 */ 191, 71, 125, 191, 30, 115, 32, 78, 53, 191,
158678	/* 1490 */ 81, 191, 191, 70, 40, 85, 213, 214, 191, 22,
158679	/* 1500 */ 90, 78, 213, 214, 81, 213, 214, 98, 140, 120,
158680	/* 1510 */ 100, 213, 214, 213, 214, 23, 106, 107, 26, 130,
158681	/* 1520 */ 191, 98, 191, 113, 70, 115, 116, 117, 23, 22,
158682	/* 1530 */ 120, 26, 78, 19, 191, 81, 19, 20, 61, 22,
158683	/* 1540 */ 191, 132, 213, 214, 213, 214, 137, 138, 59, 191,
158684	/* 1550 */ 191, 191, 98, 36, 128, 132, 213, 214, 128, 59,
158685	/* 1560 */ 137, 138, 152, 153, 154, 155, 156, 83, 84, 144,
158686	/* 1570 */ 161, 213, 214, 213, 214, 23, 59, 151, 26, 23,
158687	/* 1580 */ 23, 151, 26, 26, 161, 59, 132, 23, 71, 191,
158688	/* 1590 */ 26, 137, 138, 119, 120, 23, 19, 20, 26, 22,
158689	/* 1600 */ 223, 23, 85, 23, 26, 116, 26, 90, 191, 7,
158690	/* 1610 */ 8, 97, 152, 36, 154, 161, 116, 100, 23, 23,
158691	/* 1620 */ 191, 26, 26, 106, 107, 191, 23, 223, 23, 26,
158692	/* 1630 */ 113, 26, 115, 116, 117, 23, 59, 120, 26, 191,
158693	/* 1640 */ 191, 191, 116, 255, 191, 252, 191, 140, 71, 191,
158694	/* 1650 */ 315, 233, 191, 191, 191, 191, 191, 191, 191, 191,
158695	/* 1660 */ 191, 285, 284, 239, 252, 252, 252, 252, 240, 152,
158696	/* 1670 */ 153, 154, 155, 156, 189, 294, 268, 100, 242, 268,
158697	/* 1680 */ 264, 211, 290, 106, 107, 108, 264, 256, 256, 243,
158698	/* 1690 */ 113, 290, 115, 116, 117, 268, 217, 120, 226, 243,
158699	/* 1700 */ 222, 268, 216, 19, 20, 246, 22, 216, 256, 216,
158700	/* 1710 */ 194, 60, 38, 242, 277, 294, 240, 242, 198, 246,
158701	/* 1720 */ 36, 140, 198, 198, 19, 20, 150, 22, 149, 152,
158702	/* 1730 */ 153, 154, 155, 156, 294, 291, 291, 280, 22, 43,
158703	/* 1740 */ 231, 36, 18, 59, 234, 234, 234, 234, 267, 269,
158704	/* 1750 */ 18, 198, 197, 231, 148, 71, 269, 269, 243, 231,
158705	/* 1760 */ 198, 243, 267, 197, 59, 157, 243, 198, 62, 287,
158706	/* 1770 */ 243, 197, 22, 198, 114, 64, 71, 218, 218, 197,
158707	/* 1780 */ 286, 198, 197, 215, 100, 215, 215, 224, 22, 125,
158708	/* 1790 */ 106, 107, 164, 24, 221, 112, 143, 113, 302, 115,
158709	/* 1800 */ 116, 117, 218, 215, 120, 100, 217, 221, 215, 215,
158710	/* 1810 */ 309, 106, 107, 215, 224, 279, 279, 218, 113, 258,
158711	/* 1820 */ 115, 116, 117, 114, 257, 120, 91, 198, 82, 147,
158712	/* 1830 */ 144, 22, 274, 314, 198, 314, 152, 153, 154, 155,
158713	/* 1840 */ 156, 276, 157, 146, 145, 258, 25, 247, 257, 201,
158714	/* 1850 */ 258, 26, 200, 13, 257, 244, 246, 152, 153, 154,
158715	/* 1860 */ 155, 156, 258, 262, 257, 247, 245, 243, 192, 192,
158716	/* 1870 */ 6, 262, 204, 210, 219, 210, 210, 190, 190, 190,
158717	/* 1880 */ 210, 219, 204, 211, 211, 210, 4, 3, 22, 162,
158718	/* 1890 */ 15, 23, 16, 23, 204, 138, 129, 150, 26, 141,
158719	/* 1900 */ 20, 24, 143, 16, 1, 141, 129, 129, 61, 53,
158720	/* 1910 */ 37, 150, 297, 300, 300, 53, 53, 129, 53, 115,
158721	/* 1920 */ 34, 140, 1, 5, 22, 114, 68, 26, 160, 68,
158722	/* 1930 */ 75, 41, 140, 114, 24, 20, 19, 130, 124, 23,
158723	/* 1940 */ 96, 22, 22, 37, 22, 67, 22, 59, 67, 24,
158724	/* 1950 */ 22, 28, 67, 23, 148, 22, 97, 23, 23, 23,
158725	/* 1960 */ 140, 23, 22, 26, 23, 23, 115, 22, 142, 26,
158726	/* 1970 */ 75, 88, 75, 34, 23, 86, 44, 22, 34, 26,
158727	/* 1980 */ 34, 34, 34, 34, 93, 24, 26, 23, 34, 23,
158728	/* 1990 */ 23, 23, 23, 11, 23, 22, 26, 22, 22, 15,
158729	/* 2000 */ 23, 23, 22, 22, 1, 26, 23, 140, 134, 140,
158730	/* 2010 */ 1, 140, 316, 316, 316, 316, 316, 316, 316, 140,
158731	/* 2020 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158732	/* 2030 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158733	/* 2040 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158734	/* 2050 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158735	/* 2060 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158736	/* 2070 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158737	/* 2080 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158738	/* 2090 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158739	/* 2100 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158740	/* 2110 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158741	/* 2120 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158742	/* 2130 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158743	/* 2140 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158744	/* 2150 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158745	/* 2160 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158746	/* 2170 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158747	/* 2180 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158748	/* 2190 */ 316, 316, 316, 316, 316, 316, 316, 316, 316, 316,
158749	/* 2200 */ 316, 316, 316,
158750	};
158751	#define YY_SHIFT_COUNT (569)
158752	#define YY_SHIFT_MIN (0)
158753	#define YY_SHIFT_MAX (2009)
158754	static const unsigned short int yy_shift_ofst[] = {
158755	/* 0 */ 1423, 1409, 1454, 1192, 1192, 36, 1252, 1410, 1517, 1684,
158756	/* 10 */ 1684, 1684, 292, 0, 0, 180, 1015, 1684, 1684, 1684,
158757	/* 20 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158758	/* 30 */ 1049, 1049, 1121, 1121, 54, 400, 36, 36, 36, 36,
158759	/* 40 */ 36, 40, 110, 219, 289, 396, 439, 509, 548, 618,
158760	/* 50 */ 657, 727, 766, 836, 995, 1015, 1015, 1015, 1015, 1015,
158761	/* 60 */ 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015,
158762	/* 70 */ 1015, 1015, 1015, 1035, 1015, 1138, 880, 880, 1577, 1684,
158763	/* 80 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158764	/* 90 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158765	/* 100 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158766	/* 110 */ 1684, 1684, 1684, 1705, 1684, 1684, 1684, 1684, 1684, 1684,
158767	/* 120 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 146, 84, 84,
158768	/* 130 */ 84, 84, 84, 362, 269, 125, 97, 453, 66, 66,
158769	/* 140 */ 893, 1090, 66, 66, 533, 533, 66, 554, 554, 554,
158770	/* 150 */ 554, 192, 587, 587, 695, 25, 2020, 2020, 290, 290,
158771	/* 160 */ 290, 200, 514, 514, 514, 514, 939, 939, 442, 875,
158772	/* 170 */ 935, 66, 66, 66, 66, 66, 66, 66, 66, 66,
158773	/* 180 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
158774	/* 190 */ 66, 601, 601, 66, 729, 878, 878, 1266, 1266, 552,
158775	/* 200 */ 1023, 2020, 2020, 2020, 2020, 2020, 2020, 2020, 307, 490,
158776	/* 210 */ 490, 567, 393, 517, 467, 672, 242, 682, 675, 66,
158777	/* 220 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 616,
158778	/* 230 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
158779	/* 240 */ 66, 66, 1093, 1093, 1093, 66, 66, 66, 778, 66,
158780	/* 250 */ 66, 66, 1053, 1064, 66, 66, 1190, 66, 66, 66,
158781	/* 260 */ 66, 66, 66, 66, 66, 722, 992, 718, 253, 253,
158782	/* 270 */ 253, 253, 338, 718, 718, 888, 403, 852, 1328, 254,
158783	/* 280 */ 1295, 721, 1330, 1295, 1330, 1370, 234, 254, 254, 234,
158784	/* 290 */ 254, 721, 1370, 1357, 1492, 1348, 385, 385, 385, 1330,
158785	/* 300 */ 1425, 1425, 643, 1315, 1336, 1004, 1651, 1651, 1581, 1581,
158786	/* 310 */ 1674, 1674, 1581, 1576, 1579, 1716, 1696, 1724, 1724, 1724,
158787	/* 320 */ 1724, 1581, 1732, 1606, 1579, 1579, 1606, 1716, 1696, 1606,
158788	/* 330 */ 1696, 1606, 1581, 1732, 1608, 1706, 1581, 1732, 1750, 1581,
158789	/* 340 */ 1732, 1581, 1732, 1750, 1660, 1660, 1660, 1711, 1766, 1766,
158790	/* 350 */ 1750, 1660, 1664, 1660, 1711, 1660, 1660, 1628, 1769, 1683,
158791	/* 360 */ 1683, 1750, 1653, 1709, 1653, 1709, 1653, 1709, 1653, 1709,
158792	/* 370 */ 1581, 1735, 1735, 1746, 1746, 1682, 1686, 1809, 1581, 1685,
158793	/* 380 */ 1682, 1697, 1699, 1606, 1821, 1825, 1840, 1840, 1864, 1864,
158794	/* 390 */ 1864, 2020, 2020, 2020, 2020, 2020, 2020, 2020, 2020, 2020,
158795	/* 400 */ 2020, 2020, 2020, 2020, 2020, 2020, 599, 223, 1193, 1299,
158796	/* 410 */ 228, 780, 958, 1505, 1153, 1435, 1368, 1426, 1430, 1552,
158797	/* 420 */ 1477, 1556, 1557, 1564, 1572, 1578, 1580, 1489, 1474, 1602,
158798	/* 430 */ 1389, 1514, 1500, 1595, 1596, 1484, 1603, 1075, 1460, 1605,
158799	/* 440 */ 1612, 1526, 1507, 1882, 1884, 1866, 1727, 1875, 1876, 1868,
158800	/* 450 */ 1870, 1757, 1747, 1767, 1872, 1872, 1877, 1758, 1880, 1759,
158801	/* 460 */ 1887, 1903, 1764, 1777, 1872, 1778, 1847, 1873, 1872, 1761,
158802	/* 470 */ 1856, 1862, 1863, 1865, 1788, 1804, 1886, 1781, 1921, 1918,
158803	/* 480 */ 1902, 1811, 1768, 1858, 1901, 1861, 1855, 1890, 1792, 1819,
158804	/* 490 */ 1910, 1915, 1917, 1807, 1814, 1919, 1878, 1920, 1922, 1916,
158805	/* 500 */ 1924, 1881, 1888, 1925, 1844, 1923, 1928, 1885, 1906, 1930,
158806	/* 510 */ 1806, 1933, 1934, 1935, 1936, 1937, 1938, 1940, 1859, 1820,
158807	/* 520 */ 1941, 1942, 1851, 1939, 1945, 1826, 1943, 1944, 1946, 1947,
158808	/* 530 */ 1948, 1883, 1895, 1889, 1932, 1897, 1891, 1949, 1951, 1955,
158809	/* 540 */ 1961, 1953, 1960, 1954, 1964, 1943, 1966, 1967, 1968, 1969,
158810	/* 550 */ 1970, 1971, 1973, 1982, 1975, 1976, 1977, 1978, 1980, 1981,
158811	/* 560 */ 1979, 1874, 1867, 1869, 1871, 1879, 1983, 1984, 2003, 2009,
158812	};
158813	#define YY_REDUCE_COUNT (405)
158814	#define YY_REDUCE_MIN (-265)
158815	#define YY_REDUCE_MAX (1690)
158816	static const short yy_reduce_ofst[] = {
158817	/* 0 */ 111, 168, 386, 761, -176, -174, -191, -189, -181, -178,
158818	/* 10 */ 176, 263, 44, -207, -204, -265, -139, -114, 158, 504,
158819	/* 20 */ 525, 544, 612, 614, 650, 652, 765, 265, 703, 705,
158820	/* 30 */ 70, 714, -187, 127, 774, 713, 767, 769, 970, 1019,
158821	/* 40 */ 1021, -255, -255, -255, -255, -255, -255, -255, -255, -255,
158822	/* 50 */ -255, -255, -255, -255, -255, -255, -255, -255, -255, -255,
158823	/* 60 */ -255, -255, -255, -255, -255, -255, -255, -255, -255, -255,
158824	/* 70 */ -255, -255, -255, -255, -255, -255, -255, -255, 394, 542,
158825	/* 80 */ 816, 818, 842, 882, 902, 919, 938, 940, 957, 986,
158826	/* 90 */ 1048, 1063, 1068, 1073, 1076, 1088, 1100, 1102, 1104, 1106,
158827	/* 100 */ 1113, 1119, 1137, 1140, 1143, 1147, 1149, 1164, 1173, 1183,
158828	/* 110 */ 1185, 1188, 1202, 1204, 1247, 1259, 1263, 1283, 1289, 1292,
158829	/* 120 */ 1298, 1300, 1329, 1331, 1343, 1358, 1360, -255, -255, -255,
158830	/* 130 */ -255, -255, -255, -255, -255, 196, -255, 387, -177, 507,
158831	/* 140 */ 1002, -219, 557, -93, -167, 638, -121, 284, 500, 284,
158832	/* 150 */ 500, 247, 651, 865, -255, -255, -255, -255, -85, -85,
158833	/* 160 */ -85, 237, 171, 602, 846, 885, -212, -203, 217, 380,
158834	/* 170 */ 380, -23, 161, 653, 712, 773, 943, 990, 1040, 563,
158835	/* 180 */ 833, 971, 1005, 1042, 1092, 1078, 1043, 1144, 1184, -186,
158836	/* 190 */ 1105, 318, 869, 7, 825, 920, 1074, 704, 706, 390,
158837	/* 200 */ 1087, 1094, 336, 545, 772, 1201, 1117, 1207, -179, -137,
158838	/* 210 */ -112, -13, 18, 112, 197, 418, 495, 508, 777, 809,
158839	/* 220 */ 923, 1014, 1027, 1033, 1044, 1115, 1194, 1212, 1221, 209,
158840	/* 230 */ 1236, 1240, 1256, 1287, 1301, 1307, 1349, 1359, 1398, 1417,
158841	/* 240 */ 1429, 1434, 681, 1377, 1404, 1448, 1449, 1450, 1388, 1453,
158842	/* 250 */ 1455, 1458, 1393, 1335, 1461, 1462, 1418, 1463, 197, 1464,
158843	/* 260 */ 1465, 1466, 1467, 1468, 1469, 1376, 1378, 1424, 1412, 1413,
158844	/* 270 */ 1414, 1415, 1388, 1424, 1424, 1428, 1470, 1485, 1381, 1408,
158845	/* 280 */ 1416, 1436, 1431, 1422, 1432, 1392, 1446, 1411, 1427, 1456,
158846	/* 290 */ 1433, 1471, 1401, 1479, 1472, 1478, 1486, 1491, 1493, 1452,
158847	/* 300 */ 1459, 1473, 1437, 1475, 1476, 1516, 1421, 1440, 1520, 1524,
158848	/* 310 */ 1444, 1445, 1525, 1457, 1480, 1481, 1509, 1510, 1511, 1512,
158849	/* 320 */ 1513, 1553, 1555, 1515, 1487, 1488, 1518, 1495, 1522, 1523,
158850	/* 330 */ 1528, 1527, 1562, 1566, 1482, 1494, 1569, 1574, 1559, 1575,
158851	/* 340 */ 1582, 1583, 1585, 1560, 1568, 1570, 1571, 1563, 1573, 1586,
158852	/* 350 */ 1584, 1588, 1589, 1593, 1590, 1594, 1598, 1501, 1496, 1536,
158853	/* 360 */ 1537, 1599, 1561, 1567, 1587, 1591, 1592, 1597, 1604, 1607,
158854	/* 370 */ 1629, 1519, 1521, 1601, 1609, 1600, 1610, 1558, 1636, 1565,
158855	/* 380 */ 1618, 1621, 1611, 1624, 1648, 1652, 1676, 1677, 1687, 1688,
158856	/* 390 */ 1689, 1613, 1614, 1615, 1668, 1663, 1665, 1666, 1670, 1678,
158857	/* 400 */ 1655, 1662, 1672, 1673, 1675, 1690,
158858	};
158859	static const YYACTIONTYPE yy_default[] = {
158860	/* 0 */ 1623, 1623, 1623, 1453, 1223, 1332, 1223, 1223, 1223, 1453,
158861	/* 10 */ 1453, 1453, 1223, 1362, 1362, 1506, 1254, 1223, 1223, 1223,
158862	/* 20 */ 1223, 1223, 1223, 1223, 1223, 1223, 1223, 1452, 1223, 1223,
	@@ -159112,10 +159274,11 @@
159112	0, /* VECTOR => nothing */
159113	0, /* SELECT_COLUMN => nothing */
159114	0, /* IF_NULL_ROW => nothing */
159115	0, /* ASTERISK => nothing */
159116	0, /* SPAN => nothing */

159117	0, /* SPACE => nothing */
159118	0, /* ILLEGAL => nothing */
159119	};
159120	#endif /* YYFALLBACK */
159121
	@@ -159383,145 +159546,146 @@
159383	/* 176 */ "VECTOR",
159384	/* 177 */ "SELECT_COLUMN",
159385	/* 178 */ "IF_NULL_ROW",
159386	/* 179 */ "ASTERISK",
159387	/* 180 */ "SPAN",
159388	/* 181 */ "SPACE",
159389	/* 182 */ "ILLEGAL",
159390	/* 183 */ "input",
159391	/* 184 */ "cmdlist",
159392	/* 185 */ "ecmd",
159393	/* 186 */ "cmdx",
159394	/* 187 */ "explain",
159395	/* 188 */ "cmd",
159396	/* 189 */ "transtype",
159397	/* 190 */ "trans_opt",
159398	/* 191 */ "nm",
159399	/* 192 */ "savepoint_opt",
159400	/* 193 */ "create_table",
159401	/* 194 */ "create_table_args",
159402	/* 195 */ "createkw",
159403	/* 196 */ "temp",
159404	/* 197 */ "ifnotexists",
159405	/* 198 */ "dbnm",
159406	/* 199 */ "columnlist",
159407	/* 200 */ "conslist_opt",
159408	/* 201 */ "table_options",
159409	/* 202 */ "select",
159410	/* 203 */ "columnname",
159411	/* 204 */ "carglist",
159412	/* 205 */ "typetoken",
159413	/* 206 */ "typename",
159414	/* 207 */ "signed",
159415	/* 208 */ "plus_num",
159416	/* 209 */ "minus_num",
159417	/* 210 */ "scanpt",
159418	/* 211 */ "scantok",
159419	/* 212 */ "ccons",
159420	/* 213 */ "term",
159421	/* 214 */ "expr",
159422	/* 215 */ "onconf",
159423	/* 216 */ "sortorder",
159424	/* 217 */ "autoinc",
159425	/* 218 */ "eidlist_opt",
159426	/* 219 */ "refargs",
159427	/* 220 */ "defer_subclause",
159428	/* 221 */ "generated",
159429	/* 222 */ "refarg",
159430	/* 223 */ "refact",
159431	/* 224 */ "init_deferred_pred_opt",
159432	/* 225 */ "conslist",
159433	/* 226 */ "tconscomma",
159434	/* 227 */ "tcons",
159435	/* 228 */ "sortlist",
159436	/* 229 */ "eidlist",
159437	/* 230 */ "defer_subclause_opt",
159438	/* 231 */ "orconf",
159439	/* 232 */ "resolvetype",
159440	/* 233 */ "raisetype",
159441	/* 234 */ "ifexists",
159442	/* 235 */ "fullname",
159443	/* 236 */ "selectnowith",
159444	/* 237 */ "oneselect",
159445	/* 238 */ "wqlist",
159446	/* 239 */ "multiselect_op",
159447	/* 240 */ "distinct",
159448	/* 241 */ "selcollist",
159449	/* 242 */ "from",
159450	/* 243 */ "where_opt",
159451	/* 244 */ "groupby_opt",
159452	/* 245 */ "having_opt",
159453	/* 246 */ "orderby_opt",
159454	/* 247 */ "limit_opt",
159455	/* 248 */ "window_clause",
159456	/* 249 */ "values",
159457	/* 250 */ "nexprlist",
159458	/* 251 */ "sclp",
159459	/* 252 */ "as",
159460	/* 253 */ "seltablist",
159461	/* 254 */ "stl_prefix",
159462	/* 255 */ "joinop",
159463	/* 256 */ "indexed_opt",
159464	/* 257 */ "on_opt",
159465	/* 258 */ "using_opt",
159466	/* 259 */ "exprlist",
159467	/* 260 */ "xfullname",
159468	/* 261 */ "idlist",
159469	/* 262 */ "nulls",
159470	/* 263 */ "with",
159471	/* 264 */ "where_opt_ret",
159472	/* 265 */ "setlist",
159473	/* 266 */ "insert_cmd",
159474	/* 267 */ "idlist_opt",
159475	/* 268 */ "upsert",
159476	/* 269 */ "returning",
159477	/* 270 */ "filter_over",
159478	/* 271 */ "likeop",
159479	/* 272 */ "between_op",
159480	/* 273 */ "in_op",
159481	/* 274 */ "paren_exprlist",
159482	/* 275 */ "case_operand",
159483	/* 276 */ "case_exprlist",
159484	/* 277 */ "case_else",
159485	/* 278 */ "uniqueflag",
159486	/* 279 */ "collate",
159487	/* 280 */ "vinto",
159488	/* 281 */ "nmnum",
159489	/* 282 */ "trigger_decl",
159490	/* 283 */ "trigger_cmd_list",
159491	/* 284 */ "trigger_time",
159492	/* 285 */ "trigger_event",
159493	/* 286 */ "foreach_clause",
159494	/* 287 */ "when_clause",
159495	/* 288 */ "trigger_cmd",
159496	/* 289 */ "trnm",
159497	/* 290 */ "tridxby",
159498	/* 291 */ "database_kw_opt",
159499	/* 292 */ "key_opt",
159500	/* 293 */ "add_column_fullname",
159501	/* 294 */ "kwcolumn_opt",
159502	/* 295 */ "create_vtab",
159503	/* 296 */ "vtabarglist",
159504	/* 297 */ "vtabarg",
159505	/* 298 */ "vtabargtoken",
159506	/* 299 */ "lp",
159507	/* 300 */ "anylist",
159508	/* 301 */ "wqitem",
159509	/* 302 */ "wqas",
159510	/* 303 */ "windowdefn_list",
159511	/* 304 */ "windowdefn",
159512	/* 305 */ "window",
159513	/* 306 */ "frame_opt",
159514	/* 307 */ "part_opt",
159515	/* 308 */ "filter_clause",
159516	/* 309 */ "over_clause",
159517	/* 310 */ "range_or_rows",
159518	/* 311 */ "frame_bound",
159519	/* 312 */ "frame_bound_s",
159520	/* 313 */ "frame_bound_e",
159521	/* 314 */ "frame_exclude_opt",
159522	/* 315 */ "frame_exclude",

159523	};
159524	#endif /* defined(YYCOVERAGE) \|\| !defined(NDEBUG) */
159525
159526	#ifndef NDEBUG
159527	/* For tracing reduce actions, the names of all rules are required.
	@@ -160048,103 +160212,103 @@
160048	** Note: during a reduce, the only symbols destroyed are those
160049	** which appear on the RHS of the rule, but which are not used
160050	** inside the C code.
160051	*/
160052	/******* Begin destructor definitions *************************************/
160053	case 202: /* select */
160054	case 236: /* selectnowith */
160055	case 237: /* oneselect */
160056	case 249: /* values */
160057	{
160058	sqlite3SelectDelete(pParse->db, (yypminor->yy307));
160059	}
160060	break;
160061	case 213: /* term */
160062	case 214: /* expr */
160063	case 243: /* where_opt */
160064	case 245: /* having_opt */
160065	case 257: /* on_opt */
160066	case 264: /* where_opt_ret */
160067	case 275: /* case_operand */
160068	case 277: /* case_else */
160069	case 280: /* vinto */
160070	case 287: /* when_clause */
160071	case 292: /* key_opt */
160072	case 308: /* filter_clause */
160073	{
160074	sqlite3ExprDelete(pParse->db, (yypminor->yy602));
160075	}
160076	break;
160077	case 218: /* eidlist_opt */
160078	case 228: /* sortlist */
160079	case 229: /* eidlist */
160080	case 241: /* selcollist */
160081	case 244: /* groupby_opt */
160082	case 246: /* orderby_opt */
160083	case 250: /* nexprlist */
160084	case 251: /* sclp */
160085	case 259: /* exprlist */
160086	case 265: /* setlist */
160087	case 274: /* paren_exprlist */
160088	case 276: /* case_exprlist */
160089	case 307: /* part_opt */
160090	{
160091	sqlite3ExprListDelete(pParse->db, (yypminor->yy338));
160092	}
160093	break;
160094	case 235: /* fullname */
160095	case 242: /* from */
160096	case 253: /* seltablist */
160097	case 254: /* stl_prefix */
160098	case 260: /* xfullname */
160099	{
160100	sqlite3SrcListDelete(pParse->db, (yypminor->yy291));
160101	}
160102	break;
160103	case 238: /* wqlist */
160104	{
160105	sqlite3WithDelete(pParse->db, (yypminor->yy195));
160106	}
160107	break;
160108	case 248: /* window_clause */
160109	case 303: /* windowdefn_list */
160110	{
160111	sqlite3WindowListDelete(pParse->db, (yypminor->yy19));
160112	}
160113	break;
160114	case 258: /* using_opt */
160115	case 261: /* idlist */
160116	case 267: /* idlist_opt */
160117	{
160118	sqlite3IdListDelete(pParse->db, (yypminor->yy288));
160119	}
160120	break;
160121	case 270: /* filter_over */
160122	case 304: /* windowdefn */
160123	case 305: /* window */
160124	case 306: /* frame_opt */
160125	case 309: /* over_clause */
160126	{
160127	sqlite3WindowDelete(pParse->db, (yypminor->yy19));
160128	}
160129	break;
160130	case 283: /* trigger_cmd_list */
160131	case 288: /* trigger_cmd */
160132	{
160133	sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy483));
160134	}
160135	break;
160136	case 285: /* trigger_event */
160137	{
160138	sqlite3IdListDelete(pParse->db, (yypminor->yy50).b);
160139	}
160140	break;
160141	case 311: /* frame_bound */
160142	case 312: /* frame_bound_s */
160143	case 313: /* frame_bound_e */
160144	{
160145	sqlite3ExprDelete(pParse->db, (yypminor->yy113).pExpr);
160146	}
160147	break;
160148	/******* End destructor definitions ***************************************/
160149	default: break; /* If no destructor action specified: do nothing */
160150	}
	@@ -160431,408 +160595,408 @@
160431	}
160432
160433	/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
160434	** of that rule */
160435	static const YYCODETYPE yyRuleInfoLhs[] = {
160436	187, /* (0) explain ::= EXPLAIN */
160437	187, /* (1) explain ::= EXPLAIN QUERY PLAN */
160438	186, /* (2) cmdx ::= cmd */
160439	188, /* (3) cmd ::= BEGIN transtype trans_opt */
160440	189, /* (4) transtype ::= */
160441	189, /* (5) transtype ::= DEFERRED */
160442	189, /* (6) transtype ::= IMMEDIATE */
160443	189, /* (7) transtype ::= EXCLUSIVE */
160444	188, /* (8) cmd ::= COMMIT\|END trans_opt */
160445	188, /* (9) cmd ::= ROLLBACK trans_opt */
160446	188, /* (10) cmd ::= SAVEPOINT nm */
160447	188, /* (11) cmd ::= RELEASE savepoint_opt nm */
160448	188, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
160449	193, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
160450	195, /* (14) createkw ::= CREATE */
160451	197, /* (15) ifnotexists ::= */
160452	197, /* (16) ifnotexists ::= IF NOT EXISTS */
160453	196, /* (17) temp ::= TEMP */
160454	196, /* (18) temp ::= */
160455	194, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */
160456	194, /* (20) create_table_args ::= AS select */
160457	201, /* (21) table_options ::= */
160458	201, /* (22) table_options ::= WITHOUT nm */
160459	203, /* (23) columnname ::= nm typetoken */
160460	205, /* (24) typetoken ::= */
160461	205, /* (25) typetoken ::= typename LP signed RP */
160462	205, /* (26) typetoken ::= typename LP signed COMMA signed RP */
160463	206, /* (27) typename ::= typename ID\|STRING */
160464	210, /* (28) scanpt ::= */
160465	211, /* (29) scantok ::= */
160466	212, /* (30) ccons ::= CONSTRAINT nm */
160467	212, /* (31) ccons ::= DEFAULT scantok term */
160468	212, /* (32) ccons ::= DEFAULT LP expr RP */
160469	212, /* (33) ccons ::= DEFAULT PLUS scantok term */
160470	212, /* (34) ccons ::= DEFAULT MINUS scantok term */
160471	212, /* (35) ccons ::= DEFAULT scantok ID\|INDEXED */
160472	212, /* (36) ccons ::= NOT NULL onconf */
160473	212, /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */
160474	212, /* (38) ccons ::= UNIQUE onconf */
160475	212, /* (39) ccons ::= CHECK LP expr RP */
160476	212, /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */
160477	212, /* (41) ccons ::= defer_subclause */
160478	212, /* (42) ccons ::= COLLATE ID\|STRING */
160479	221, /* (43) generated ::= LP expr RP */
160480	221, /* (44) generated ::= LP expr RP ID */
160481	217, /* (45) autoinc ::= */
160482	217, /* (46) autoinc ::= AUTOINCR */
160483	219, /* (47) refargs ::= */
160484	219, /* (48) refargs ::= refargs refarg */
160485	222, /* (49) refarg ::= MATCH nm */
160486	222, /* (50) refarg ::= ON INSERT refact */
160487	222, /* (51) refarg ::= ON DELETE refact */
160488	222, /* (52) refarg ::= ON UPDATE refact */
160489	223, /* (53) refact ::= SET NULL */
160490	223, /* (54) refact ::= SET DEFAULT */
160491	223, /* (55) refact ::= CASCADE */
160492	223, /* (56) refact ::= RESTRICT */
160493	223, /* (57) refact ::= NO ACTION */
160494	220, /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
160495	220, /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
160496	224, /* (60) init_deferred_pred_opt ::= */
160497	224, /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */
160498	224, /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
160499	200, /* (63) conslist_opt ::= */
160500	226, /* (64) tconscomma ::= COMMA */
160501	227, /* (65) tcons ::= CONSTRAINT nm */
160502	227, /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
160503	227, /* (67) tcons ::= UNIQUE LP sortlist RP onconf */
160504	227, /* (68) tcons ::= CHECK LP expr RP onconf */
160505	227, /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
160506	230, /* (70) defer_subclause_opt ::= */
160507	215, /* (71) onconf ::= */
160508	215, /* (72) onconf ::= ON CONFLICT resolvetype */
160509	231, /* (73) orconf ::= */
160510	231, /* (74) orconf ::= OR resolvetype */
160511	232, /* (75) resolvetype ::= IGNORE */
160512	232, /* (76) resolvetype ::= REPLACE */
160513	188, /* (77) cmd ::= DROP TABLE ifexists fullname */
160514	234, /* (78) ifexists ::= IF EXISTS */
160515	234, /* (79) ifexists ::= */
160516	188, /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
160517	188, /* (81) cmd ::= DROP VIEW ifexists fullname */
160518	188, /* (82) cmd ::= select */
160519	202, /* (83) select ::= WITH wqlist selectnowith */
160520	202, /* (84) select ::= WITH RECURSIVE wqlist selectnowith */
160521	202, /* (85) select ::= selectnowith */
160522	236, /* (86) selectnowith ::= selectnowith multiselect_op oneselect */
160523	239, /* (87) multiselect_op ::= UNION */
160524	239, /* (88) multiselect_op ::= UNION ALL */
160525	239, /* (89) multiselect_op ::= EXCEPT\|INTERSECT */
160526	237, /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
160527	237, /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
160528	249, /* (92) values ::= VALUES LP nexprlist RP */
160529	249, /* (93) values ::= values COMMA LP nexprlist RP */
160530	240, /* (94) distinct ::= DISTINCT */
160531	240, /* (95) distinct ::= ALL */
160532	240, /* (96) distinct ::= */
160533	251, /* (97) sclp ::= */
160534	241, /* (98) selcollist ::= sclp scanpt expr scanpt as */
160535	241, /* (99) selcollist ::= sclp scanpt STAR */
160536	241, /* (100) selcollist ::= sclp scanpt nm DOT STAR */
160537	252, /* (101) as ::= AS nm */
160538	252, /* (102) as ::= */
160539	242, /* (103) from ::= */
160540	242, /* (104) from ::= FROM seltablist */
160541	254, /* (105) stl_prefix ::= seltablist joinop */
160542	254, /* (106) stl_prefix ::= */
160543	253, /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
160544	253, /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
160545	253, /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
160546	253, /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
160547	198, /* (111) dbnm ::= */
160548	198, /* (112) dbnm ::= DOT nm */
160549	235, /* (113) fullname ::= nm */
160550	235, /* (114) fullname ::= nm DOT nm */
160551	260, /* (115) xfullname ::= nm */
160552	260, /* (116) xfullname ::= nm DOT nm */
160553	260, /* (117) xfullname ::= nm DOT nm AS nm */
160554	260, /* (118) xfullname ::= nm AS nm */
160555	255, /* (119) joinop ::= COMMA\|JOIN */
160556	255, /* (120) joinop ::= JOIN_KW JOIN */
160557	255, /* (121) joinop ::= JOIN_KW nm JOIN */
160558	255, /* (122) joinop ::= JOIN_KW nm nm JOIN */
160559	257, /* (123) on_opt ::= ON expr */
160560	257, /* (124) on_opt ::= */
160561	256, /* (125) indexed_opt ::= */
160562	256, /* (126) indexed_opt ::= INDEXED BY nm */
160563	256, /* (127) indexed_opt ::= NOT INDEXED */
160564	258, /* (128) using_opt ::= USING LP idlist RP */
160565	258, /* (129) using_opt ::= */
160566	246, /* (130) orderby_opt ::= */
160567	246, /* (131) orderby_opt ::= ORDER BY sortlist */
160568	228, /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */
160569	228, /* (133) sortlist ::= expr sortorder nulls */
160570	216, /* (134) sortorder ::= ASC */
160571	216, /* (135) sortorder ::= DESC */
160572	216, /* (136) sortorder ::= */
160573	262, /* (137) nulls ::= NULLS FIRST */
160574	262, /* (138) nulls ::= NULLS LAST */
160575	262, /* (139) nulls ::= */
160576	244, /* (140) groupby_opt ::= */
160577	244, /* (141) groupby_opt ::= GROUP BY nexprlist */
160578	245, /* (142) having_opt ::= */
160579	245, /* (143) having_opt ::= HAVING expr */
160580	247, /* (144) limit_opt ::= */
160581	247, /* (145) limit_opt ::= LIMIT expr */
160582	247, /* (146) limit_opt ::= LIMIT expr OFFSET expr */
160583	247, /* (147) limit_opt ::= LIMIT expr COMMA expr */
160584	188, /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
160585	243, /* (149) where_opt ::= */
160586	243, /* (150) where_opt ::= WHERE expr */
160587	264, /* (151) where_opt_ret ::= */
160588	264, /* (152) where_opt_ret ::= WHERE expr */
160589	264, /* (153) where_opt_ret ::= RETURNING selcollist */
160590	264, /* (154) where_opt_ret ::= WHERE expr RETURNING selcollist */
160591	188, /* (155) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
160592	265, /* (156) setlist ::= setlist COMMA nm EQ expr */
160593	265, /* (157) setlist ::= setlist COMMA LP idlist RP EQ expr */
160594	265, /* (158) setlist ::= nm EQ expr */
160595	265, /* (159) setlist ::= LP idlist RP EQ expr */
160596	188, /* (160) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
160597	188, /* (161) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
160598	268, /* (162) upsert ::= */
160599	268, /* (163) upsert ::= RETURNING selcollist */
160600	268, /* (164) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
160601	268, /* (165) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
160602	268, /* (166) upsert ::= ON CONFLICT DO NOTHING returning */
160603	268, /* (167) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
160604	269, /* (168) returning ::= RETURNING selcollist */
160605	266, /* (169) insert_cmd ::= INSERT orconf */
160606	266, /* (170) insert_cmd ::= REPLACE */
160607	267, /* (171) idlist_opt ::= */
160608	267, /* (172) idlist_opt ::= LP idlist RP */
160609	261, /* (173) idlist ::= idlist COMMA nm */
160610	261, /* (174) idlist ::= nm */
160611	214, /* (175) expr ::= LP expr RP */
160612	214, /* (176) expr ::= ID\|INDEXED */
160613	214, /* (177) expr ::= JOIN_KW */
160614	214, /* (178) expr ::= nm DOT nm */
160615	214, /* (179) expr ::= nm DOT nm DOT nm */
160616	213, /* (180) term ::= NULL\|FLOAT\|BLOB */
160617	213, /* (181) term ::= STRING */
160618	213, /* (182) term ::= INTEGER */
160619	214, /* (183) expr ::= VARIABLE */
160620	214, /* (184) expr ::= expr COLLATE ID\|STRING */
160621	214, /* (185) expr ::= CAST LP expr AS typetoken RP */
160622	214, /* (186) expr ::= ID\|INDEXED LP distinct exprlist RP */
160623	214, /* (187) expr ::= ID\|INDEXED LP STAR RP */
160624	214, /* (188) expr ::= ID\|INDEXED LP distinct exprlist RP filter_over */
160625	214, /* (189) expr ::= ID\|INDEXED LP STAR RP filter_over */
160626	213, /* (190) term ::= CTIME_KW */
160627	214, /* (191) expr ::= LP nexprlist COMMA expr RP */
160628	214, /* (192) expr ::= expr AND expr */
160629	214, /* (193) expr ::= expr OR expr */
160630	214, /* (194) expr ::= expr LT\|GT\|GE\|LE expr */
160631	214, /* (195) expr ::= expr EQ\|NE expr */
160632	214, /* (196) expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */
160633	214, /* (197) expr ::= expr PLUS\|MINUS expr */
160634	214, /* (198) expr ::= expr STAR\|SLASH\|REM expr */
160635	214, /* (199) expr ::= expr CONCAT expr */
160636	271, /* (200) likeop ::= NOT LIKE_KW\|MATCH */
160637	214, /* (201) expr ::= expr likeop expr */
160638	214, /* (202) expr ::= expr likeop expr ESCAPE expr */
160639	214, /* (203) expr ::= expr ISNULL\|NOTNULL */
160640	214, /* (204) expr ::= expr NOT NULL */
160641	214, /* (205) expr ::= expr IS expr */
160642	214, /* (206) expr ::= expr IS NOT expr */
160643	214, /* (207) expr ::= NOT expr */
160644	214, /* (208) expr ::= BITNOT expr */
160645	214, /* (209) expr ::= PLUS\|MINUS expr */
160646	272, /* (210) between_op ::= BETWEEN */
160647	272, /* (211) between_op ::= NOT BETWEEN */
160648	214, /* (212) expr ::= expr between_op expr AND expr */
160649	273, /* (213) in_op ::= IN */
160650	273, /* (214) in_op ::= NOT IN */
160651	214, /* (215) expr ::= expr in_op LP exprlist RP */
160652	214, /* (216) expr ::= LP select RP */
160653	214, /* (217) expr ::= expr in_op LP select RP */
160654	214, /* (218) expr ::= expr in_op nm dbnm paren_exprlist */
160655	214, /* (219) expr ::= EXISTS LP select RP */
160656	214, /* (220) expr ::= CASE case_operand case_exprlist case_else END */
160657	276, /* (221) case_exprlist ::= case_exprlist WHEN expr THEN expr */
160658	276, /* (222) case_exprlist ::= WHEN expr THEN expr */
160659	277, /* (223) case_else ::= ELSE expr */
160660	277, /* (224) case_else ::= */
160661	275, /* (225) case_operand ::= expr */
160662	275, /* (226) case_operand ::= */
160663	259, /* (227) exprlist ::= */
160664	250, /* (228) nexprlist ::= nexprlist COMMA expr */
160665	250, /* (229) nexprlist ::= expr */
160666	274, /* (230) paren_exprlist ::= */
160667	274, /* (231) paren_exprlist ::= LP exprlist RP */
160668	188, /* (232) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
160669	278, /* (233) uniqueflag ::= UNIQUE */
160670	278, /* (234) uniqueflag ::= */
160671	218, /* (235) eidlist_opt ::= */
160672	218, /* (236) eidlist_opt ::= LP eidlist RP */
160673	229, /* (237) eidlist ::= eidlist COMMA nm collate sortorder */
160674	229, /* (238) eidlist ::= nm collate sortorder */
160675	279, /* (239) collate ::= */
160676	279, /* (240) collate ::= COLLATE ID\|STRING */
160677	188, /* (241) cmd ::= DROP INDEX ifexists fullname */
160678	188, /* (242) cmd ::= VACUUM vinto */
160679	188, /* (243) cmd ::= VACUUM nm vinto */
160680	280, /* (244) vinto ::= INTO expr */
160681	280, /* (245) vinto ::= */
160682	188, /* (246) cmd ::= PRAGMA nm dbnm */
160683	188, /* (247) cmd ::= PRAGMA nm dbnm EQ nmnum */
160684	188, /* (248) cmd ::= PRAGMA nm dbnm LP nmnum RP */
160685	188, /* (249) cmd ::= PRAGMA nm dbnm EQ minus_num */
160686	188, /* (250) cmd ::= PRAGMA nm dbnm LP minus_num RP */
160687	208, /* (251) plus_num ::= PLUS INTEGER\|FLOAT */
160688	209, /* (252) minus_num ::= MINUS INTEGER\|FLOAT */
160689	188, /* (253) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
160690	282, /* (254) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
160691	284, /* (255) trigger_time ::= BEFORE\|AFTER */
160692	284, /* (256) trigger_time ::= INSTEAD OF */
160693	284, /* (257) trigger_time ::= */
160694	285, /* (258) trigger_event ::= DELETE\|INSERT */
160695	285, /* (259) trigger_event ::= UPDATE */
160696	285, /* (260) trigger_event ::= UPDATE OF idlist */
160697	287, /* (261) when_clause ::= */
160698	287, /* (262) when_clause ::= WHEN expr */
160699	283, /* (263) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
160700	283, /* (264) trigger_cmd_list ::= trigger_cmd SEMI */
160701	289, /* (265) trnm ::= nm DOT nm */
160702	290, /* (266) tridxby ::= INDEXED BY nm */
160703	290, /* (267) tridxby ::= NOT INDEXED */
160704	288, /* (268) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
160705	288, /* (269) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
160706	288, /* (270) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
160707	288, /* (271) trigger_cmd ::= scanpt select scanpt */
160708	214, /* (272) expr ::= RAISE LP IGNORE RP */
160709	214, /* (273) expr ::= RAISE LP raisetype COMMA nm RP */
160710	233, /* (274) raisetype ::= ROLLBACK */
160711	233, /* (275) raisetype ::= ABORT */
160712	233, /* (276) raisetype ::= FAIL */
160713	188, /* (277) cmd ::= DROP TRIGGER ifexists fullname */
160714	188, /* (278) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
160715	188, /* (279) cmd ::= DETACH database_kw_opt expr */
160716	292, /* (280) key_opt ::= */
160717	292, /* (281) key_opt ::= KEY expr */
160718	188, /* (282) cmd ::= REINDEX */
160719	188, /* (283) cmd ::= REINDEX nm dbnm */
160720	188, /* (284) cmd ::= ANALYZE */
160721	188, /* (285) cmd ::= ANALYZE nm dbnm */
160722	188, /* (286) cmd ::= ALTER TABLE fullname RENAME TO nm */
160723	188, /* (287) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
160724	188, /* (288) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
160725	293, /* (289) add_column_fullname ::= fullname */
160726	188, /* (290) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
160727	188, /* (291) cmd ::= create_vtab */
160728	188, /* (292) cmd ::= create_vtab LP vtabarglist RP */
160729	295, /* (293) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
160730	297, /* (294) vtabarg ::= */
160731	298, /* (295) vtabargtoken ::= ANY */
160732	298, /* (296) vtabargtoken ::= lp anylist RP */
160733	299, /* (297) lp ::= LP */
160734	263, /* (298) with ::= WITH wqlist */
160735	263, /* (299) with ::= WITH RECURSIVE wqlist */
160736	302, /* (300) wqas ::= AS */
160737	302, /* (301) wqas ::= AS MATERIALIZED */
160738	302, /* (302) wqas ::= AS NOT MATERIALIZED */
160739	301, /* (303) wqitem ::= nm eidlist_opt wqas LP select RP */
160740	238, /* (304) wqlist ::= wqitem */
160741	238, /* (305) wqlist ::= wqlist COMMA wqitem */
160742	303, /* (306) windowdefn_list ::= windowdefn */
160743	303, /* (307) windowdefn_list ::= windowdefn_list COMMA windowdefn */
160744	304, /* (308) windowdefn ::= nm AS LP window RP */
160745	305, /* (309) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
160746	305, /* (310) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
160747	305, /* (311) window ::= ORDER BY sortlist frame_opt */
160748	305, /* (312) window ::= nm ORDER BY sortlist frame_opt */
160749	305, /* (313) window ::= frame_opt */
160750	305, /* (314) window ::= nm frame_opt */
160751	306, /* (315) frame_opt ::= */
160752	306, /* (316) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
160753	306, /* (317) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
160754	310, /* (318) range_or_rows ::= RANGE\|ROWS\|GROUPS */
160755	312, /* (319) frame_bound_s ::= frame_bound */
160756	312, /* (320) frame_bound_s ::= UNBOUNDED PRECEDING */
160757	313, /* (321) frame_bound_e ::= frame_bound */
160758	313, /* (322) frame_bound_e ::= UNBOUNDED FOLLOWING */
160759	311, /* (323) frame_bound ::= expr PRECEDING\|FOLLOWING */
160760	311, /* (324) frame_bound ::= CURRENT ROW */
160761	314, /* (325) frame_exclude_opt ::= */
160762	314, /* (326) frame_exclude_opt ::= EXCLUDE frame_exclude */
160763	315, /* (327) frame_exclude ::= NO OTHERS */
160764	315, /* (328) frame_exclude ::= CURRENT ROW */
160765	315, /* (329) frame_exclude ::= GROUP\|TIES */
160766	248, /* (330) window_clause ::= WINDOW windowdefn_list */
160767	270, /* (331) filter_over ::= filter_clause over_clause */
160768	270, /* (332) filter_over ::= over_clause */
160769	270, /* (333) filter_over ::= filter_clause */
160770	309, /* (334) over_clause ::= OVER LP window RP */
160771	309, /* (335) over_clause ::= OVER nm */
160772	308, /* (336) filter_clause ::= FILTER LP WHERE expr RP */
160773	183, /* (337) input ::= cmdlist */
160774	184, /* (338) cmdlist ::= cmdlist ecmd */
160775	184, /* (339) cmdlist ::= ecmd */
160776	185, /* (340) ecmd ::= SEMI */
160777	185, /* (341) ecmd ::= cmdx SEMI */
160778	185, /* (342) ecmd ::= explain cmdx SEMI */
160779	190, /* (343) trans_opt ::= */
160780	190, /* (344) trans_opt ::= TRANSACTION */
160781	190, /* (345) trans_opt ::= TRANSACTION nm */
160782	192, /* (346) savepoint_opt ::= SAVEPOINT */
160783	192, /* (347) savepoint_opt ::= */
160784	188, /* (348) cmd ::= create_table create_table_args */
160785	199, /* (349) columnlist ::= columnlist COMMA columnname carglist */
160786	199, /* (350) columnlist ::= columnname carglist */
160787	191, /* (351) nm ::= ID\|INDEXED */
160788	191, /* (352) nm ::= STRING */
160789	191, /* (353) nm ::= JOIN_KW */
160790	205, /* (354) typetoken ::= typename */
160791	206, /* (355) typename ::= ID\|STRING */
160792	207, /* (356) signed ::= plus_num */
160793	207, /* (357) signed ::= minus_num */
160794	204, /* (358) carglist ::= carglist ccons */
160795	204, /* (359) carglist ::= */
160796	212, /* (360) ccons ::= NULL onconf */
160797	212, /* (361) ccons ::= GENERATED ALWAYS AS generated */
160798	212, /* (362) ccons ::= AS generated */
160799	200, /* (363) conslist_opt ::= COMMA conslist */
160800	225, /* (364) conslist ::= conslist tconscomma tcons */
160801	225, /* (365) conslist ::= tcons */
160802	226, /* (366) tconscomma ::= */
160803	230, /* (367) defer_subclause_opt ::= defer_subclause */
160804	232, /* (368) resolvetype ::= raisetype */
160805	236, /* (369) selectnowith ::= oneselect */
160806	237, /* (370) oneselect ::= values */
160807	251, /* (371) sclp ::= selcollist COMMA */
160808	252, /* (372) as ::= ID\|STRING */
160809	269, /* (373) returning ::= */
160810	214, /* (374) expr ::= term */
160811	271, /* (375) likeop ::= LIKE_KW\|MATCH */
160812	259, /* (376) exprlist ::= nexprlist */
160813	281, /* (377) nmnum ::= plus_num */
160814	281, /* (378) nmnum ::= nm */
160815	281, /* (379) nmnum ::= ON */
160816	281, /* (380) nmnum ::= DELETE */
160817	281, /* (381) nmnum ::= DEFAULT */
160818	208, /* (382) plus_num ::= INTEGER\|FLOAT */
160819	286, /* (383) foreach_clause ::= */
160820	286, /* (384) foreach_clause ::= FOR EACH ROW */
160821	289, /* (385) trnm ::= nm */
160822	290, /* (386) tridxby ::= */
160823	291, /* (387) database_kw_opt ::= DATABASE */
160824	291, /* (388) database_kw_opt ::= */
160825	294, /* (389) kwcolumn_opt ::= */
160826	294, /* (390) kwcolumn_opt ::= COLUMNKW */
160827	296, /* (391) vtabarglist ::= vtabarg */
160828	296, /* (392) vtabarglist ::= vtabarglist COMMA vtabarg */
160829	297, /* (393) vtabarg ::= vtabarg vtabargtoken */
160830	300, /* (394) anylist ::= */
160831	300, /* (395) anylist ::= anylist LP anylist RP */
160832	300, /* (396) anylist ::= anylist ANY */
160833	263, /* (397) with ::= */
160834	};
160835
160836	/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
160837	** of symbols on the right-hand side of that rule. */
160838	static const signed char yyRuleInfoNRhs[] = {
	@@ -161283,20 +161447,20 @@
161283	break;
161284	case 2: /* cmdx ::= cmd */
161285	{ sqlite3FinishCoding(pParse); }
161286	break;
161287	case 3: /* cmd ::= BEGIN transtype trans_opt */
161288	{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy60);}
161289	break;
161290	case 4: /* transtype ::= */
161291	{yymsp[1].minor.yy60 = TK_DEFERRED;}
161292	break;
161293	case 5: /* transtype ::= DEFERRED */
161294	case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
161295	case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
161296	case 318: /* range_or_rows ::= RANGE\|ROWS\|GROUPS */ yytestcase(yyruleno==318);
161297	{yymsp[0].minor.yy60 = yymsp[0].major; /A-overwrites-X/}
161298	break;
161299	case 8: /* cmd ::= COMMIT\|END trans_opt */
161300	case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
161301	{sqlite3EndTransaction(pParse,yymsp[-1].major);}
161302	break;
	@@ -161315,11 +161479,11 @@
161315	sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
161316	}
161317	break;
161318	case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
161319	{
161320	sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy60,0,0,yymsp[-2].minor.yy60);
161321	}
161322	break;
161323	case 14: /* createkw ::= CREATE */
161324	{disableLookaside(pParse);}
161325	break;
	@@ -161330,35 +161494,35 @@
161330	case 60: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==60);
161331	case 70: /* defer_subclause_opt ::= */ yytestcase(yyruleno==70);
161332	case 79: /* ifexists ::= */ yytestcase(yyruleno==79);
161333	case 96: /* distinct ::= */ yytestcase(yyruleno==96);
161334	case 239: /* collate ::= */ yytestcase(yyruleno==239);
161335	{yymsp[1].minor.yy60 = 0;}
161336	break;
161337	case 16: /* ifnotexists ::= IF NOT EXISTS */
161338	{yymsp[-2].minor.yy60 = 1;}
161339	break;
161340	case 17: /* temp ::= TEMP */
161341	{yymsp[0].minor.yy60 = pParse->db->init.busy==0;}
161342	break;
161343	case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_options */
161344	{
161345	sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy60,0);
161346	}
161347	break;
161348	case 20: /* create_table_args ::= AS select */
161349	{
161350	sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy307);
161351	sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy307);
161352	}
161353	break;
161354	case 22: /* table_options ::= WITHOUT nm */
161355	{
161356	if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
161357	yymsp[-1].minor.yy60 = TF_WithoutRowid \| TF_NoVisibleRowid;
161358	}else{
161359	yymsp[-1].minor.yy60 = 0;
161360	sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
161361	}
161362	}
161363	break;
161364	case 23: /* columnname ::= nm typetoken */
	@@ -161383,11 +161547,11 @@
161383	{yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
161384	break;
161385	case 28: /* scanpt ::= */
161386	{
161387	assert( yyLookahead!=YYNOCODE );
161388	yymsp[1].minor.yy528 = yyLookaheadToken.z;
161389	}
161390	break;
161391	case 29: /* scantok ::= */
161392	{
161393	assert( yyLookahead!=YYNOCODE );
	@@ -161397,21 +161561,21 @@
161397	case 30: /* ccons ::= CONSTRAINT nm */
161398	case 65: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==65);
161399	{pParse->constraintName = yymsp[0].minor.yy0;}
161400	break;
161401	case 31: /* ccons ::= DEFAULT scantok term */
161402	{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy602,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
161403	break;
161404	case 32: /* ccons ::= DEFAULT LP expr RP */
161405	{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy602,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
161406	break;
161407	case 33: /* ccons ::= DEFAULT PLUS scantok term */
161408	{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy602,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
161409	break;
161410	case 34: /* ccons ::= DEFAULT MINUS scantok term */
161411	{
161412	Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy602, 0);
161413	sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
161414	}
161415	break;
161416	case 35: /* ccons ::= DEFAULT scantok ID\|INDEXED */
161417	{
	@@ -161422,259 +161586,259 @@
161422	}
161423	sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
161424	}
161425	break;
161426	case 36: /* ccons ::= NOT NULL onconf */
161427	{sqlite3AddNotNull(pParse, yymsp[0].minor.yy60);}
161428	break;
161429	case 37: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
161430	{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy60,yymsp[0].minor.yy60,yymsp[-2].minor.yy60);}
161431	break;
161432	case 38: /* ccons ::= UNIQUE onconf */
161433	{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy60,0,0,0,0,
161434	SQLITE_IDXTYPE_UNIQUE);}
161435	break;
161436	case 39: /* ccons ::= CHECK LP expr RP */
161437	{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy602,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
161438	break;
161439	case 40: /* ccons ::= REFERENCES nm eidlist_opt refargs */
161440	{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy338,yymsp[0].minor.yy60);}
161441	break;
161442	case 41: /* ccons ::= defer_subclause */
161443	{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy60);}
161444	break;
161445	case 42: /* ccons ::= COLLATE ID\|STRING */
161446	{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
161447	break;
161448	case 43: /* generated ::= LP expr RP */
161449	{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy602,0);}
161450	break;
161451	case 44: /* generated ::= LP expr RP ID */
161452	{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy602,&yymsp[0].minor.yy0);}
161453	break;
161454	case 46: /* autoinc ::= AUTOINCR */
161455	{yymsp[0].minor.yy60 = 1;}
161456	break;
161457	case 47: /* refargs ::= */
161458	{ yymsp[1].minor.yy60 = OE_None0x0101; / EV: R-19803-45884 */}
161459	break;
161460	case 48: /* refargs ::= refargs refarg */
161461	{ yymsp[-1].minor.yy60 = (yymsp[-1].minor.yy60 & ~yymsp[0].minor.yy615.mask) \| yymsp[0].minor.yy615.value; }
161462	break;
161463	case 49: /* refarg ::= MATCH nm */
161464	{ yymsp[-1].minor.yy615.value = 0; yymsp[-1].minor.yy615.mask = 0x000000; }
161465	break;
161466	case 50: /* refarg ::= ON INSERT refact */
161467	{ yymsp[-2].minor.yy615.value = 0; yymsp[-2].minor.yy615.mask = 0x000000; }
161468	break;
161469	case 51: /* refarg ::= ON DELETE refact */
161470	{ yymsp[-2].minor.yy615.value = yymsp[0].minor.yy60; yymsp[-2].minor.yy615.mask = 0x0000ff; }
161471	break;
161472	case 52: /* refarg ::= ON UPDATE refact */
161473	{ yymsp[-2].minor.yy615.value = yymsp[0].minor.yy60<<8; yymsp[-2].minor.yy615.mask = 0x00ff00; }
161474	break;
161475	case 53: /* refact ::= SET NULL */
161476	{ yymsp[-1].minor.yy60 = OE_SetNull; /* EV: R-33326-45252 */}
161477	break;
161478	case 54: /* refact ::= SET DEFAULT */
161479	{ yymsp[-1].minor.yy60 = OE_SetDflt; /* EV: R-33326-45252 */}
161480	break;
161481	case 55: /* refact ::= CASCADE */
161482	{ yymsp[0].minor.yy60 = OE_Cascade; /* EV: R-33326-45252 */}
161483	break;
161484	case 56: /* refact ::= RESTRICT */
161485	{ yymsp[0].minor.yy60 = OE_Restrict; /* EV: R-33326-45252 */}
161486	break;
161487	case 57: /* refact ::= NO ACTION */
161488	{ yymsp[-1].minor.yy60 = OE_None; /* EV: R-33326-45252 */}
161489	break;
161490	case 58: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
161491	{yymsp[-2].minor.yy60 = 0;}
161492	break;
161493	case 59: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
161494	case 74: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==74);
161495	case 169: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==169);
161496	{yymsp[-1].minor.yy60 = yymsp[0].minor.yy60;}
161497	break;
161498	case 61: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
161499	case 78: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==78);
161500	case 211: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==211);
161501	case 214: /* in_op ::= NOT IN */ yytestcase(yyruleno==214);
161502	case 240: /* collate ::= COLLATE ID\|STRING */ yytestcase(yyruleno==240);
161503	{yymsp[-1].minor.yy60 = 1;}
161504	break;
161505	case 62: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
161506	{yymsp[-1].minor.yy60 = 0;}
161507	break;
161508	case 64: /* tconscomma ::= COMMA */
161509	{pParse->constraintName.n = 0;}
161510	break;
161511	case 66: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
161512	{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy338,yymsp[0].minor.yy60,yymsp[-2].minor.yy60,0);}
161513	break;
161514	case 67: /* tcons ::= UNIQUE LP sortlist RP onconf */
161515	{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy338,yymsp[0].minor.yy60,0,0,0,0,
161516	SQLITE_IDXTYPE_UNIQUE);}
161517	break;
161518	case 68: /* tcons ::= CHECK LP expr RP onconf */
161519	{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy602,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
161520	break;
161521	case 69: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
161522	{
161523	sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy338, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy338, yymsp[-1].minor.yy60);
161524	sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy60);
161525	}
161526	break;
161527	case 71: /* onconf ::= */
161528	case 73: /* orconf ::= */ yytestcase(yyruleno==73);
161529	{yymsp[1].minor.yy60 = OE_Default;}
161530	break;
161531	case 72: /* onconf ::= ON CONFLICT resolvetype */
161532	{yymsp[-2].minor.yy60 = yymsp[0].minor.yy60;}
161533	break;
161534	case 75: /* resolvetype ::= IGNORE */
161535	{yymsp[0].minor.yy60 = OE_Ignore;}
161536	break;
161537	case 76: /* resolvetype ::= REPLACE */
161538	case 170: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==170);
161539	{yymsp[0].minor.yy60 = OE_Replace;}
161540	break;
161541	case 77: /* cmd ::= DROP TABLE ifexists fullname */
161542	{
161543	sqlite3DropTable(pParse, yymsp[0].minor.yy291, 0, yymsp[-1].minor.yy60);
161544	}
161545	break;
161546	case 80: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
161547	{
161548	sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy338, yymsp[0].minor.yy307, yymsp[-7].minor.yy60, yymsp[-5].minor.yy60);
161549	}
161550	break;
161551	case 81: /* cmd ::= DROP VIEW ifexists fullname */
161552	{
161553	sqlite3DropTable(pParse, yymsp[0].minor.yy291, 1, yymsp[-1].minor.yy60);
161554	}
161555	break;
161556	case 82: /* cmd ::= select */
161557	{
161558	SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
161559	sqlite3Select(pParse, yymsp[0].minor.yy307, &dest);
161560	sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy307);
161561	}
161562	break;
161563	case 83: /* select ::= WITH wqlist selectnowith */
161564	{yymsp[-2].minor.yy307 = attachWithToSelect(pParse,yymsp[0].minor.yy307,yymsp[-1].minor.yy195);}
161565	break;
161566	case 84: /* select ::= WITH RECURSIVE wqlist selectnowith */
161567	{yymsp[-3].minor.yy307 = attachWithToSelect(pParse,yymsp[0].minor.yy307,yymsp[-1].minor.yy195);}
161568	break;
161569	case 85: /* select ::= selectnowith */
161570	{
161571	Select *p = yymsp[0].minor.yy307;
161572	if( p ){
161573	parserDoubleLinkSelect(pParse, p);
161574	}
161575	yymsp[0].minor.yy307 = p; /A-overwrites-X/
161576	}
161577	break;
161578	case 86: /* selectnowith ::= selectnowith multiselect_op oneselect */
161579	{
161580	Select *pRhs = yymsp[0].minor.yy307;
161581	Select *pLhs = yymsp[-2].minor.yy307;
161582	if( pRhs && pRhs->pPrior ){
161583	SrcList *pFrom;
161584	Token x;
161585	x.n = 0;
161586	parserDoubleLinkSelect(pParse, pRhs);
161587	pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);
161588	pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
161589	}
161590	if( pRhs ){
161591	pRhs->op = (u8)yymsp[-1].minor.yy60;
161592	pRhs->pPrior = pLhs;
161593	if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
161594	pRhs->selFlags &= ~SF_MultiValue;
161595	if( yymsp[-1].minor.yy60!=TK_ALL ) pParse->hasCompound = 1;
161596	}else{
161597	sqlite3SelectDelete(pParse->db, pLhs);
161598	}
161599	yymsp[-2].minor.yy307 = pRhs;
161600	}
161601	break;
161602	case 87: /* multiselect_op ::= UNION */
161603	case 89: /* multiselect_op ::= EXCEPT\|INTERSECT */ yytestcase(yyruleno==89);
161604	{yymsp[0].minor.yy60 = yymsp[0].major; /A-overwrites-OP/}
161605	break;
161606	case 88: /* multiselect_op ::= UNION ALL */
161607	{yymsp[-1].minor.yy60 = TK_ALL;}
161608	break;
161609	case 90: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
161610	{
161611	yymsp[-8].minor.yy307 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy338,yymsp[-5].minor.yy291,yymsp[-4].minor.yy602,yymsp[-3].minor.yy338,yymsp[-2].minor.yy602,yymsp[-1].minor.yy338,yymsp[-7].minor.yy60,yymsp[0].minor.yy602);
161612	}
161613	break;
161614	case 91: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
161615	{
161616	yymsp[-9].minor.yy307 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy338,yymsp[-6].minor.yy291,yymsp[-5].minor.yy602,yymsp[-4].minor.yy338,yymsp[-3].minor.yy602,yymsp[-1].minor.yy338,yymsp[-8].minor.yy60,yymsp[0].minor.yy602);
161617	if( yymsp[-9].minor.yy307 ){
161618	yymsp[-9].minor.yy307->pWinDefn = yymsp[-2].minor.yy19;
161619	}else{
161620	sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy19);
161621	}
161622	}
161623	break;
161624	case 92: /* values ::= VALUES LP nexprlist RP */
161625	{
161626	yymsp[-3].minor.yy307 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy338,0,0,0,0,0,SF_Values,0);
161627	}
161628	break;
161629	case 93: /* values ::= values COMMA LP nexprlist RP */
161630	{
161631	Select pRight, pLeft = yymsp[-4].minor.yy307;
161632	pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy338,0,0,0,0,0,SF_Values\|SF_MultiValue,0);
161633	if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
161634	if( pRight ){
161635	pRight->op = TK_ALL;
161636	pRight->pPrior = pLeft;
161637	yymsp[-4].minor.yy307 = pRight;
161638	}else{
161639	yymsp[-4].minor.yy307 = pLeft;
161640	}
161641	}
161642	break;
161643	case 94: /* distinct ::= DISTINCT */
161644	{yymsp[0].minor.yy60 = SF_Distinct;}
161645	break;
161646	case 95: /* distinct ::= ALL */
161647	{yymsp[0].minor.yy60 = SF_All;}
161648	break;
161649	case 97: /* sclp ::= */
161650	case 130: /* orderby_opt ::= */ yytestcase(yyruleno==130);
161651	case 140: /* groupby_opt ::= */ yytestcase(yyruleno==140);
161652	case 227: /* exprlist ::= */ yytestcase(yyruleno==227);
161653	case 230: /* paren_exprlist ::= */ yytestcase(yyruleno==230);
161654	case 235: /* eidlist_opt ::= */ yytestcase(yyruleno==235);
161655	{yymsp[1].minor.yy338 = 0;}
161656	break;
161657	case 98: /* selcollist ::= sclp scanpt expr scanpt as */
161658	{
161659	yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy338, yymsp[-2].minor.yy602);
161660	if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy338, &yymsp[0].minor.yy0, 1);
161661	sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy338,yymsp[-3].minor.yy528,yymsp[-1].minor.yy528);
161662	}
161663	break;
161664	case 99: /* selcollist ::= sclp scanpt STAR */
161665	{
161666	Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
161667	yymsp[-2].minor.yy338 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy338, p);
161668	}
161669	break;
161670	case 100: /* selcollist ::= sclp scanpt nm DOT STAR */
161671	{
161672	Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
161673	Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
161674	Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
161675	yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy338, pDot);
161676	}
161677	break;
161678	case 101: /* as ::= AS nm */
161679	case 112: /* dbnm ::= DOT nm */ yytestcase(yyruleno==112);
161680	case 251: /* plus_num ::= PLUS INTEGER\|FLOAT */ yytestcase(yyruleno==251);
	@@ -161681,49 +161845,49 @@
161681	case 252: /* minus_num ::= MINUS INTEGER\|FLOAT */ yytestcase(yyruleno==252);
161682	{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
161683	break;
161684	case 103: /* from ::= */
161685	case 106: /* stl_prefix ::= */ yytestcase(yyruleno==106);
161686	{yymsp[1].minor.yy291 = 0;}
161687	break;
161688	case 104: /* from ::= FROM seltablist */
161689	{
161690	yymsp[-1].minor.yy291 = yymsp[0].minor.yy291;
161691	sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy291);
161692	}
161693	break;
161694	case 105: /* stl_prefix ::= seltablist joinop */
161695	{
161696	if( ALWAYS(yymsp[-1].minor.yy291 && yymsp[-1].minor.yy291->nSrc>0) ) yymsp[-1].minor.yy291->a[yymsp[-1].minor.yy291->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy60;
161697	}
161698	break;
161699	case 107: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
161700	{
161701	yymsp[-6].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy291,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
161702	sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy291, &yymsp[-2].minor.yy0);
161703	}
161704	break;
161705	case 108: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
161706	{
161707	yymsp[-8].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy291,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
161708	sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy291, yymsp[-4].minor.yy338);
161709	}
161710	break;
161711	case 109: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
161712	{
161713	yymsp[-6].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy291,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy307,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
161714	}
161715	break;
161716	case 110: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
161717	{
161718	if( yymsp[-6].minor.yy291==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy602==0 && yymsp[0].minor.yy288==0 ){
161719	yymsp[-6].minor.yy291 = yymsp[-4].minor.yy291;
161720	}else if( yymsp[-4].minor.yy291->nSrc==1 ){
161721	yymsp[-6].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy291,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
161722	if( yymsp[-6].minor.yy291 ){
161723	SrcItem *pNew = &yymsp[-6].minor.yy291->a[yymsp[-6].minor.yy291->nSrc-1];
161724	SrcItem *pOld = yymsp[-4].minor.yy291->a;
161725	pNew->zName = pOld->zName;
161726	pNew->zDatabase = pOld->zDatabase;
161727	pNew->pSelect = pOld->pSelect;
161728	if( pOld->fg.isTabFunc ){
161729	pNew->u1.pFuncArg = pOld->u1.pFuncArg;
	@@ -161732,240 +161896,240 @@
161732	pNew->fg.isTabFunc = 1;
161733	}
161734	pOld->zName = pOld->zDatabase = 0;
161735	pOld->pSelect = 0;
161736	}
161737	sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy291);
161738	}else{
161739	Select *pSubquery;
161740	sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy291);
161741	pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy291,0,0,0,0,SF_NestedFrom,0);
161742	yymsp[-6].minor.yy291 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy291,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy602,yymsp[0].minor.yy288);
161743	}
161744	}
161745	break;
161746	case 111: /* dbnm ::= */
161747	case 125: /* indexed_opt ::= */ yytestcase(yyruleno==125);
161748	{yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
161749	break;
161750	case 113: /* fullname ::= nm */
161751	{
161752	yylhsminor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
161753	if( IN_RENAME_OBJECT && yylhsminor.yy291 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy291->a[0].zName, &yymsp[0].minor.yy0);
161754	}
161755	yymsp[0].minor.yy291 = yylhsminor.yy291;
161756	break;
161757	case 114: /* fullname ::= nm DOT nm */
161758	{
161759	yylhsminor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
161760	if( IN_RENAME_OBJECT && yylhsminor.yy291 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy291->a[0].zName, &yymsp[0].minor.yy0);
161761	}
161762	yymsp[-2].minor.yy291 = yylhsminor.yy291;
161763	break;
161764	case 115: /* xfullname ::= nm */
161765	{yymsp[0].minor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /A-overwrites-X/}
161766	break;
161767	case 116: /* xfullname ::= nm DOT nm */
161768	{yymsp[-2].minor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/}
161769	break;
161770	case 117: /* xfullname ::= nm DOT nm AS nm */
161771	{
161772	yymsp[-4].minor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /A-overwrites-X/
161773	if( yymsp[-4].minor.yy291 ) yymsp[-4].minor.yy291->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
161774	}
161775	break;
161776	case 118: /* xfullname ::= nm AS nm */
161777	{
161778	yymsp[-2].minor.yy291 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /A-overwrites-X/
161779	if( yymsp[-2].minor.yy291 ) yymsp[-2].minor.yy291->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
161780	}
161781	break;
161782	case 119: /* joinop ::= COMMA\|JOIN */
161783	{ yymsp[0].minor.yy60 = JT_INNER; }
161784	break;
161785	case 120: /* joinop ::= JOIN_KW JOIN */
161786	{yymsp[-1].minor.yy60 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /X-overwrites-A/}
161787	break;
161788	case 121: /* joinop ::= JOIN_KW nm JOIN */
161789	{yymsp[-2].minor.yy60 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /X-overwrites-A/}
161790	break;
161791	case 122: /* joinop ::= JOIN_KW nm nm JOIN */
161792	{yymsp[-3].minor.yy60 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/X-overwrites-A/}
161793	break;
161794	case 123: /* on_opt ::= ON expr */
161795	case 143: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==143);
161796	case 150: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==150);
161797	case 152: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==152);
161798	case 223: /* case_else ::= ELSE expr */ yytestcase(yyruleno==223);
161799	case 244: /* vinto ::= INTO expr */ yytestcase(yyruleno==244);
161800	{yymsp[-1].minor.yy602 = yymsp[0].minor.yy602;}
161801	break;
161802	case 124: /* on_opt ::= */
161803	case 142: /* having_opt ::= */ yytestcase(yyruleno==142);
161804	case 144: /* limit_opt ::= */ yytestcase(yyruleno==144);
161805	case 149: /* where_opt ::= */ yytestcase(yyruleno==149);
161806	case 151: /* where_opt_ret ::= */ yytestcase(yyruleno==151);
161807	case 224: /* case_else ::= */ yytestcase(yyruleno==224);
161808	case 226: /* case_operand ::= */ yytestcase(yyruleno==226);
161809	case 245: /* vinto ::= */ yytestcase(yyruleno==245);
161810	{yymsp[1].minor.yy602 = 0;}
161811	break;
161812	case 126: /* indexed_opt ::= INDEXED BY nm */
161813	{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
161814	break;
161815	case 127: /* indexed_opt ::= NOT INDEXED */
161816	{yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
161817	break;
161818	case 128: /* using_opt ::= USING LP idlist RP */
161819	{yymsp[-3].minor.yy288 = yymsp[-1].minor.yy288;}
161820	break;
161821	case 129: /* using_opt ::= */
161822	case 171: /* idlist_opt ::= */ yytestcase(yyruleno==171);
161823	{yymsp[1].minor.yy288 = 0;}
161824	break;
161825	case 131: /* orderby_opt ::= ORDER BY sortlist */
161826	case 141: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==141);
161827	{yymsp[-2].minor.yy338 = yymsp[0].minor.yy338;}
161828	break;
161829	case 132: /* sortlist ::= sortlist COMMA expr sortorder nulls */
161830	{
161831	yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy338,yymsp[-2].minor.yy602);
161832	sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy338,yymsp[-1].minor.yy60,yymsp[0].minor.yy60);
161833	}
161834	break;
161835	case 133: /* sortlist ::= expr sortorder nulls */
161836	{
161837	yymsp[-2].minor.yy338 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy602); /A-overwrites-Y/
161838	sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy338,yymsp[-1].minor.yy60,yymsp[0].minor.yy60);
161839	}
161840	break;
161841	case 134: /* sortorder ::= ASC */
161842	{yymsp[0].minor.yy60 = SQLITE_SO_ASC;}
161843	break;
161844	case 135: /* sortorder ::= DESC */
161845	{yymsp[0].minor.yy60 = SQLITE_SO_DESC;}
161846	break;
161847	case 136: /* sortorder ::= */
161848	case 139: /* nulls ::= */ yytestcase(yyruleno==139);
161849	{yymsp[1].minor.yy60 = SQLITE_SO_UNDEFINED;}
161850	break;
161851	case 137: /* nulls ::= NULLS FIRST */
161852	{yymsp[-1].minor.yy60 = SQLITE_SO_ASC;}
161853	break;
161854	case 138: /* nulls ::= NULLS LAST */
161855	{yymsp[-1].minor.yy60 = SQLITE_SO_DESC;}
161856	break;
161857	case 145: /* limit_opt ::= LIMIT expr */
161858	{yymsp[-1].minor.yy602 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy602,0);}
161859	break;
161860	case 146: /* limit_opt ::= LIMIT expr OFFSET expr */
161861	{yymsp[-3].minor.yy602 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy602,yymsp[0].minor.yy602);}
161862	break;
161863	case 147: /* limit_opt ::= LIMIT expr COMMA expr */
161864	{yymsp[-3].minor.yy602 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy602,yymsp[-2].minor.yy602);}
161865	break;
161866	case 148: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
161867	{
161868	sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy291, &yymsp[-1].minor.yy0);
161869	sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy291,yymsp[0].minor.yy602,0,0);
161870	}
161871	break;
161872	case 153: /* where_opt_ret ::= RETURNING selcollist */
161873	{sqlite3AddReturning(pParse,yymsp[0].minor.yy338); yymsp[-1].minor.yy602 = 0;}
161874	break;
161875	case 154: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
161876	{sqlite3AddReturning(pParse,yymsp[0].minor.yy338); yymsp[-3].minor.yy602 = yymsp[-2].minor.yy602;}
161877	break;
161878	case 155: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
161879	{
161880	sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy291, &yymsp[-4].minor.yy0);
161881	sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy338,"set list");
161882	yymsp[-5].minor.yy291 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy291, yymsp[-1].minor.yy291);
161883	sqlite3Update(pParse,yymsp[-5].minor.yy291,yymsp[-2].minor.yy338,yymsp[0].minor.yy602,yymsp[-6].minor.yy60,0,0,0);
161884	}
161885	break;
161886	case 156: /* setlist ::= setlist COMMA nm EQ expr */
161887	{
161888	yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy338, yymsp[0].minor.yy602);
161889	sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy338, &yymsp[-2].minor.yy0, 1);
161890	}
161891	break;
161892	case 157: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
161893	{
161894	yymsp[-6].minor.yy338 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy338, yymsp[-3].minor.yy288, yymsp[0].minor.yy602);
161895	}
161896	break;
161897	case 158: /* setlist ::= nm EQ expr */
161898	{
161899	yylhsminor.yy338 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy602);
161900	sqlite3ExprListSetName(pParse, yylhsminor.yy338, &yymsp[-2].minor.yy0, 1);
161901	}
161902	yymsp[-2].minor.yy338 = yylhsminor.yy338;
161903	break;
161904	case 159: /* setlist ::= LP idlist RP EQ expr */
161905	{
161906	yymsp[-4].minor.yy338 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy288, yymsp[0].minor.yy602);
161907	}
161908	break;
161909	case 160: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
161910	{
161911	sqlite3Insert(pParse, yymsp[-3].minor.yy291, yymsp[-1].minor.yy307, yymsp[-2].minor.yy288, yymsp[-5].minor.yy60, yymsp[0].minor.yy178);
161912	}
161913	break;
161914	case 161: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
161915	{
161916	sqlite3Insert(pParse, yymsp[-4].minor.yy291, 0, yymsp[-3].minor.yy288, yymsp[-6].minor.yy60, 0);
161917	}
161918	break;
161919	case 162: /* upsert ::= */
161920	{ yymsp[1].minor.yy178 = 0; }
161921	break;
161922	case 163: /* upsert ::= RETURNING selcollist */
161923	{ yymsp[-1].minor.yy178 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy338); }
161924	break;
161925	case 164: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
161926	{ yymsp[-11].minor.yy178 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy338,yymsp[-6].minor.yy602,yymsp[-2].minor.yy338,yymsp[-1].minor.yy602,yymsp[0].minor.yy178);}
161927	break;
161928	case 165: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
161929	{ yymsp[-8].minor.yy178 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy338,yymsp[-3].minor.yy602,0,0,yymsp[0].minor.yy178); }
161930	break;
161931	case 166: /* upsert ::= ON CONFLICT DO NOTHING returning */
161932	{ yymsp[-4].minor.yy178 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
161933	break;
161934	case 167: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
161935	{ yymsp[-7].minor.yy178 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy338,yymsp[-1].minor.yy602,0);}
161936	break;
161937	case 168: /* returning ::= RETURNING selcollist */
161938	{sqlite3AddReturning(pParse,yymsp[0].minor.yy338);}
161939	break;
161940	case 172: /* idlist_opt ::= LP idlist RP */
161941	{yymsp[-2].minor.yy288 = yymsp[-1].minor.yy288;}
161942	break;
161943	case 173: /* idlist ::= idlist COMMA nm */
161944	{yymsp[-2].minor.yy288 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy288,&yymsp[0].minor.yy0);}
161945	break;
161946	case 174: /* idlist ::= nm */
161947	{yymsp[0].minor.yy288 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /A-overwrites-Y/}
161948	break;
161949	case 175: /* expr ::= LP expr RP */
161950	{yymsp[-2].minor.yy602 = yymsp[-1].minor.yy602;}
161951	break;
161952	case 176: /* expr ::= ID\|INDEXED */
161953	case 177: /* expr ::= JOIN_KW */ yytestcase(yyruleno==177);
161954	{yymsp[0].minor.yy602=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /A-overwrites-X/}
161955	break;
161956	case 178: /* expr ::= nm DOT nm */
161957	{
161958	Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
161959	Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1);
161960	if( IN_RENAME_OBJECT ){
161961	sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0);
161962	sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0);
161963	}
161964	yylhsminor.yy602 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
161965	}
161966	yymsp[-2].minor.yy602 = yylhsminor.yy602;
161967	break;
161968	case 179: /* expr ::= nm DOT nm DOT nm */
161969	{
161970	Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-4].minor.yy0, 1);
161971	Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
	@@ -161973,322 +162137,322 @@
161973	Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
161974	if( IN_RENAME_OBJECT ){
161975	sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0);
161976	sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0);
161977	}
161978	yylhsminor.yy602 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
161979	}
161980	yymsp[-4].minor.yy602 = yylhsminor.yy602;
161981	break;
161982	case 180: /* term ::= NULL\|FLOAT\|BLOB */
161983	case 181: /* term ::= STRING */ yytestcase(yyruleno==181);
161984	{yymsp[0].minor.yy602=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /A-overwrites-X/}
161985	break;
161986	case 182: /* term ::= INTEGER */
161987	{
161988	yylhsminor.yy602 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
161989	}
161990	yymsp[0].minor.yy602 = yylhsminor.yy602;
161991	break;
161992	case 183: /* expr ::= VARIABLE */
161993	{
161994	if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
161995	u32 n = yymsp[0].minor.yy0.n;
161996	yymsp[0].minor.yy602 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
161997	sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy602, n);
161998	}else{
161999	/* When doing a nested parse, one can include terms in an expression
162000	** that look like this: #1 #2 ... These terms refer to registers
162001	** in the virtual machine. #N is the N-th register. */
162002	Token t = yymsp[0].minor.yy0; /A-overwrites-X/
162003	assert( t.n>=2 );
162004	if( pParse->nested==0 ){
162005	sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
162006	yymsp[0].minor.yy602 = 0;
162007	}else{
162008	yymsp[0].minor.yy602 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
162009	if( yymsp[0].minor.yy602 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy602->iTable);
162010	}
162011	}
162012	}
162013	break;
162014	case 184: /* expr ::= expr COLLATE ID\|STRING */
162015	{
162016	yymsp[-2].minor.yy602 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy602, &yymsp[0].minor.yy0, 1);
162017	}
162018	break;
162019	case 185: /* expr ::= CAST LP expr AS typetoken RP */
162020	{
162021	yymsp[-5].minor.yy602 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
162022	sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy602, yymsp[-3].minor.yy602, 0);
162023	}
162024	break;
162025	case 186: /* expr ::= ID\|INDEXED LP distinct exprlist RP */
162026	{
162027	yylhsminor.yy602 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy338, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy60);
162028	}
162029	yymsp[-4].minor.yy602 = yylhsminor.yy602;
162030	break;
162031	case 187: /* expr ::= ID\|INDEXED LP STAR RP */
162032	{
162033	yylhsminor.yy602 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
162034	}
162035	yymsp[-3].minor.yy602 = yylhsminor.yy602;
162036	break;
162037	case 188: /* expr ::= ID\|INDEXED LP distinct exprlist RP filter_over */
162038	{
162039	yylhsminor.yy602 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy338, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy60);
162040	sqlite3WindowAttach(pParse, yylhsminor.yy602, yymsp[0].minor.yy19);
162041	}
162042	yymsp[-5].minor.yy602 = yylhsminor.yy602;
162043	break;
162044	case 189: /* expr ::= ID\|INDEXED LP STAR RP filter_over */
162045	{
162046	yylhsminor.yy602 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
162047	sqlite3WindowAttach(pParse, yylhsminor.yy602, yymsp[0].minor.yy19);
162048	}
162049	yymsp[-4].minor.yy602 = yylhsminor.yy602;
162050	break;
162051	case 190: /* term ::= CTIME_KW */
162052	{
162053	yylhsminor.yy602 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
162054	}
162055	yymsp[0].minor.yy602 = yylhsminor.yy602;
162056	break;
162057	case 191: /* expr ::= LP nexprlist COMMA expr RP */
162058	{
162059	ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy338, yymsp[-1].minor.yy602);
162060	yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
162061	if( yymsp[-4].minor.yy602 ){
162062	yymsp[-4].minor.yy602->x.pList = pList;
162063	if( ALWAYS(pList->nExpr) ){
162064	yymsp[-4].minor.yy602->flags \|= pList->a[0].pExpr->flags & EP_Propagate;
162065	}
162066	}else{
162067	sqlite3ExprListDelete(pParse->db, pList);
162068	}
162069	}
162070	break;
162071	case 192: /* expr ::= expr AND expr */
162072	{yymsp[-2].minor.yy602=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy602,yymsp[0].minor.yy602);}
162073	break;
162074	case 193: /* expr ::= expr OR expr */
162075	case 194: /* expr ::= expr LT\|GT\|GE\|LE expr */ yytestcase(yyruleno==194);
162076	case 195: /* expr ::= expr EQ\|NE expr */ yytestcase(yyruleno==195);
162077	case 196: /* expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */ yytestcase(yyruleno==196);
162078	case 197: /* expr ::= expr PLUS\|MINUS expr */ yytestcase(yyruleno==197);
162079	case 198: /* expr ::= expr STAR\|SLASH\|REM expr */ yytestcase(yyruleno==198);
162080	case 199: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==199);
162081	{yymsp[-2].minor.yy602=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy602,yymsp[0].minor.yy602);}
162082	break;
162083	case 200: /* likeop ::= NOT LIKE_KW\|MATCH */
162084	{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n\|=0x80000000; /yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0/}
162085	break;
162086	case 201: /* expr ::= expr likeop expr */
162087	{
162088	ExprList *pList;
162089	int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
162090	yymsp[-1].minor.yy0.n &= 0x7fffffff;
162091	pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy602);
162092	pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy602);
162093	yymsp[-2].minor.yy602 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
162094	if( bNot ) yymsp[-2].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy602, 0);
162095	if( yymsp[-2].minor.yy602 ) yymsp[-2].minor.yy602->flags \|= EP_InfixFunc;
162096	}
162097	break;
162098	case 202: /* expr ::= expr likeop expr ESCAPE expr */
162099	{
162100	ExprList *pList;
162101	int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
162102	yymsp[-3].minor.yy0.n &= 0x7fffffff;
162103	pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy602);
162104	pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy602);
162105	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy602);
162106	yymsp[-4].minor.yy602 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
162107	if( bNot ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
162108	if( yymsp[-4].minor.yy602 ) yymsp[-4].minor.yy602->flags \|= EP_InfixFunc;
162109	}
162110	break;
162111	case 203: /* expr ::= expr ISNULL\|NOTNULL */
162112	{yymsp[-1].minor.yy602 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy602,0);}
162113	break;
162114	case 204: /* expr ::= expr NOT NULL */
162115	{yymsp[-2].minor.yy602 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy602,0);}
162116	break;
162117	case 205: /* expr ::= expr IS expr */
162118	{
162119	yymsp[-2].minor.yy602 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy602,yymsp[0].minor.yy602);
162120	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy602, yymsp[-2].minor.yy602, TK_ISNULL);
162121	}
162122	break;
162123	case 206: /* expr ::= expr IS NOT expr */
162124	{
162125	yymsp[-3].minor.yy602 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy602,yymsp[0].minor.yy602);
162126	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy602, yymsp[-3].minor.yy602, TK_NOTNULL);
162127	}
162128	break;
162129	case 207: /* expr ::= NOT expr */
162130	case 208: /* expr ::= BITNOT expr */ yytestcase(yyruleno==208);
162131	{yymsp[-1].minor.yy602 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy602, 0);/A-overwrites-B/}
162132	break;
162133	case 209: /* expr ::= PLUS\|MINUS expr */
162134	{
162135	yymsp[-1].minor.yy602 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy602, 0);
162136	/A-overwrites-B/
162137	}
162138	break;
162139	case 210: /* between_op ::= BETWEEN */
162140	case 213: /* in_op ::= IN */ yytestcase(yyruleno==213);
162141	{yymsp[0].minor.yy60 = 0;}
162142	break;
162143	case 212: /* expr ::= expr between_op expr AND expr */
162144	{
162145	ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy602);
162146	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy602);
162147	yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy602, 0);
162148	if( yymsp[-4].minor.yy602 ){
162149	yymsp[-4].minor.yy602->x.pList = pList;
162150	}else{
162151	sqlite3ExprListDelete(pParse->db, pList);
162152	}
162153	if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
162154	}
162155	break;
162156	case 215: /* expr ::= expr in_op LP exprlist RP */
162157	{
162158	if( yymsp[-1].minor.yy338==0 ){
162159	/* Expressions of the form
162160	**
162161	** expr1 IN ()
162162	** expr1 NOT IN ()
162163	**
162164	** simplify to constants 0 (false) and 1 (true), respectively,
162165	** regardless of the value of expr1.
162166	*/
162167	sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy602);
162168	yymsp[-4].minor.yy602 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy60 ? "1" : "0");
162169	}else if( yymsp[-1].minor.yy338->nExpr==1 && sqlite3ExprIsConstant(yymsp[-1].minor.yy338->a[0].pExpr) ){
162170	Expr *pRHS = yymsp[-1].minor.yy338->a[0].pExpr;
162171	yymsp[-1].minor.yy338->a[0].pExpr = 0;
162172	sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy338);
162173	pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
162174	yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy602, pRHS);
162175	if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
162176	}else{
162177	yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy602, 0);
162178	if( yymsp[-4].minor.yy602 ){
162179	yymsp[-4].minor.yy602->x.pList = yymsp[-1].minor.yy338;
162180	sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy602);
162181	}else{
162182	sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy338);
162183	}
162184	if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
162185	}
162186	}
162187	break;
162188	case 216: /* expr ::= LP select RP */
162189	{
162190	yymsp[-2].minor.yy602 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
162191	sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy602, yymsp[-1].minor.yy307);
162192	}
162193	break;
162194	case 217: /* expr ::= expr in_op LP select RP */
162195	{
162196	yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy602, 0);
162197	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy602, yymsp[-1].minor.yy307);
162198	if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
162199	}
162200	break;
162201	case 218: /* expr ::= expr in_op nm dbnm paren_exprlist */
162202	{
162203	SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
162204	Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
162205	if( yymsp[0].minor.yy338 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy338);
162206	yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy602, 0);
162207	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy602, pSelect);
162208	if( yymsp[-3].minor.yy60 ) yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy602, 0);
162209	}
162210	break;
162211	case 219: /* expr ::= EXISTS LP select RP */
162212	{
162213	Expr *p;
162214	p = yymsp[-3].minor.yy602 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
162215	sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy307);
162216	}
162217	break;
162218	case 220: /* expr ::= CASE case_operand case_exprlist case_else END */
162219	{
162220	yymsp[-4].minor.yy602 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy602, 0);
162221	if( yymsp[-4].minor.yy602 ){
162222	yymsp[-4].minor.yy602->x.pList = yymsp[-1].minor.yy602 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy338,yymsp[-1].minor.yy602) : yymsp[-2].minor.yy338;
162223	sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy602);
162224	}else{
162225	sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy338);
162226	sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy602);
162227	}
162228	}
162229	break;
162230	case 221: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
162231	{
162232	yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy338, yymsp[-2].minor.yy602);
162233	yymsp[-4].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy338, yymsp[0].minor.yy602);
162234	}
162235	break;
162236	case 222: /* case_exprlist ::= WHEN expr THEN expr */
162237	{
162238	yymsp[-3].minor.yy338 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy602);
162239	yymsp[-3].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy338, yymsp[0].minor.yy602);
162240	}
162241	break;
162242	case 225: /* case_operand ::= expr */
162243	{yymsp[0].minor.yy602 = yymsp[0].minor.yy602; /A-overwrites-X/}
162244	break;
162245	case 228: /* nexprlist ::= nexprlist COMMA expr */
162246	{yymsp[-2].minor.yy338 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy338,yymsp[0].minor.yy602);}
162247	break;
162248	case 229: /* nexprlist ::= expr */
162249	{yymsp[0].minor.yy338 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy602); /A-overwrites-Y/}
162250	break;
162251	case 231: /* paren_exprlist ::= LP exprlist RP */
162252	case 236: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==236);
162253	{yymsp[-2].minor.yy338 = yymsp[-1].minor.yy338;}
162254	break;
162255	case 232: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
162256	{
162257	sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
162258	sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy338, yymsp[-10].minor.yy60,
162259	&yymsp[-11].minor.yy0, yymsp[0].minor.yy602, SQLITE_SO_ASC, yymsp[-8].minor.yy60, SQLITE_IDXTYPE_APPDEF);
162260	if( IN_RENAME_OBJECT && pParse->pNewIndex ){
162261	sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
162262	}
162263	}
162264	break;
162265	case 233: /* uniqueflag ::= UNIQUE */
162266	case 275: /* raisetype ::= ABORT */ yytestcase(yyruleno==275);
162267	{yymsp[0].minor.yy60 = OE_Abort;}
162268	break;
162269	case 234: /* uniqueflag ::= */
162270	{yymsp[1].minor.yy60 = OE_None;}
162271	break;
162272	case 237: /* eidlist ::= eidlist COMMA nm collate sortorder */
162273	{
162274	yymsp[-4].minor.yy338 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy338, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy60, yymsp[0].minor.yy60);
162275	}
162276	break;
162277	case 238: /* eidlist ::= nm collate sortorder */
162278	{
162279	yymsp[-2].minor.yy338 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy60, yymsp[0].minor.yy60); /A-overwrites-Y/
162280	}
162281	break;
162282	case 241: /* cmd ::= DROP INDEX ifexists fullname */
162283	{sqlite3DropIndex(pParse, yymsp[0].minor.yy291, yymsp[-1].minor.yy60);}
162284	break;
162285	case 242: /* cmd ::= VACUUM vinto */
162286	{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy602);}
162287	break;
162288	case 243: /* cmd ::= VACUUM nm vinto */
162289	{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy602);}
162290	break;
162291	case 246: /* cmd ::= PRAGMA nm dbnm */
162292	{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
162293	break;
162294	case 247: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
	@@ -162306,54 +162470,54 @@
162306	case 253: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
162307	{
162308	Token all;
162309	all.z = yymsp[-3].minor.yy0.z;
162310	all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
162311	sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy483, &all);
162312	}
162313	break;
162314	case 254: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
162315	{
162316	sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy60, yymsp[-4].minor.yy50.a, yymsp[-4].minor.yy50.b, yymsp[-2].minor.yy291, yymsp[0].minor.yy602, yymsp[-10].minor.yy60, yymsp[-8].minor.yy60);
162317	yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /A-overwrites-T/
162318	}
162319	break;
162320	case 255: /* trigger_time ::= BEFORE\|AFTER */
162321	{ yymsp[0].minor.yy60 = yymsp[0].major; /A-overwrites-X/ }
162322	break;
162323	case 256: /* trigger_time ::= INSTEAD OF */
162324	{ yymsp[-1].minor.yy60 = TK_INSTEAD;}
162325	break;
162326	case 257: /* trigger_time ::= */
162327	{ yymsp[1].minor.yy60 = TK_BEFORE; }
162328	break;
162329	case 258: /* trigger_event ::= DELETE\|INSERT */
162330	case 259: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==259);
162331	{yymsp[0].minor.yy50.a = yymsp[0].major; /A-overwrites-X/ yymsp[0].minor.yy50.b = 0;}
162332	break;
162333	case 260: /* trigger_event ::= UPDATE OF idlist */
162334	{yymsp[-2].minor.yy50.a = TK_UPDATE; yymsp[-2].minor.yy50.b = yymsp[0].minor.yy288;}
162335	break;
162336	case 261: /* when_clause ::= */
162337	case 280: /* key_opt ::= */ yytestcase(yyruleno==280);
162338	{ yymsp[1].minor.yy602 = 0; }
162339	break;
162340	case 262: /* when_clause ::= WHEN expr */
162341	case 281: /* key_opt ::= KEY expr */ yytestcase(yyruleno==281);
162342	{ yymsp[-1].minor.yy602 = yymsp[0].minor.yy602; }
162343	break;
162344	case 263: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
162345	{
162346	assert( yymsp[-2].minor.yy483!=0 );
162347	yymsp[-2].minor.yy483->pLast->pNext = yymsp[-1].minor.yy483;
162348	yymsp[-2].minor.yy483->pLast = yymsp[-1].minor.yy483;
162349	}
162350	break;
162351	case 264: /* trigger_cmd_list ::= trigger_cmd SEMI */
162352	{
162353	assert( yymsp[-1].minor.yy483!=0 );
162354	yymsp[-1].minor.yy483->pLast = yymsp[-1].minor.yy483;
162355	}
162356	break;
162357	case 265: /* trnm ::= nm DOT nm */
162358	{
162359	yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
	@@ -162375,62 +162539,62 @@
162375	"the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
162376	"within triggers");
162377	}
162378	break;
162379	case 268: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
162380	{yylhsminor.yy483 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy291, yymsp[-3].minor.yy338, yymsp[-1].minor.yy602, yymsp[-7].minor.yy60, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy528);}
162381	yymsp[-8].minor.yy483 = yylhsminor.yy483;
162382	break;
162383	case 269: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
162384	{
162385	yylhsminor.yy483 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy288,yymsp[-2].minor.yy307,yymsp[-6].minor.yy60,yymsp[-1].minor.yy178,yymsp[-7].minor.yy528,yymsp[0].minor.yy528);/yylhsminor.yy483-overwrites-yymsp[-6].minor.yy60/
162386	}
162387	yymsp[-7].minor.yy483 = yylhsminor.yy483;
162388	break;
162389	case 270: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
162390	{yylhsminor.yy483 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy602, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy528);}
162391	yymsp[-5].minor.yy483 = yylhsminor.yy483;
162392	break;
162393	case 271: /* trigger_cmd ::= scanpt select scanpt */
162394	{yylhsminor.yy483 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy307, yymsp[-2].minor.yy528, yymsp[0].minor.yy528); /yylhsminor.yy483-overwrites-yymsp[-1].minor.yy307/}
162395	yymsp[-2].minor.yy483 = yylhsminor.yy483;
162396	break;
162397	case 272: /* expr ::= RAISE LP IGNORE RP */
162398	{
162399	yymsp[-3].minor.yy602 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
162400	if( yymsp[-3].minor.yy602 ){
162401	yymsp[-3].minor.yy602->affExpr = OE_Ignore;
162402	}
162403	}
162404	break;
162405	case 273: /* expr ::= RAISE LP raisetype COMMA nm RP */
162406	{
162407	yymsp[-5].minor.yy602 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
162408	if( yymsp[-5].minor.yy602 ) {
162409	yymsp[-5].minor.yy602->affExpr = (char)yymsp[-3].minor.yy60;
162410	}
162411	}
162412	break;
162413	case 274: /* raisetype ::= ROLLBACK */
162414	{yymsp[0].minor.yy60 = OE_Rollback;}
162415	break;
162416	case 276: /* raisetype ::= FAIL */
162417	{yymsp[0].minor.yy60 = OE_Fail;}
162418	break;
162419	case 277: /* cmd ::= DROP TRIGGER ifexists fullname */
162420	{
162421	sqlite3DropTrigger(pParse,yymsp[0].minor.yy291,yymsp[-1].minor.yy60);
162422	}
162423	break;
162424	case 278: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
162425	{
162426	sqlite3Attach(pParse, yymsp[-3].minor.yy602, yymsp[-1].minor.yy602, yymsp[0].minor.yy602);
162427	}
162428	break;
162429	case 279: /* cmd ::= DETACH database_kw_opt expr */
162430	{
162431	sqlite3Detach(pParse, yymsp[0].minor.yy602);
162432	}
162433	break;
162434	case 282: /* cmd ::= REINDEX */
162435	{sqlite3Reindex(pParse, 0, 0);}
162436	break;
	@@ -162443,11 +162607,11 @@
162443	case 285: /* cmd ::= ANALYZE nm dbnm */
162444	{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
162445	break;
162446	case 286: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
162447	{
162448	sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy291,&yymsp[0].minor.yy0);
162449	}
162450	break;
162451	case 287: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
162452	{
162453	yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
	@@ -162454,22 +162618,22 @@
162454	sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
162455	}
162456	break;
162457	case 288: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
162458	{
162459	sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy291, &yymsp[0].minor.yy0);
162460	}
162461	break;
162462	case 289: /* add_column_fullname ::= fullname */
162463	{
162464	disableLookaside(pParse);
162465	sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy291);
162466	}
162467	break;
162468	case 290: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
162469	{
162470	sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy291, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
162471	}
162472	break;
162473	case 291: /* cmd ::= create_vtab */
162474	{sqlite3VtabFinishParse(pParse,0);}
162475	break;
	@@ -162476,11 +162640,11 @@
162476	case 292: /* cmd ::= create_vtab LP vtabarglist RP */
162477	{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
162478	break;
162479	case 293: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
162480	{
162481	sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy60);
162482	}
162483	break;
162484	case 294: /* vtabarg ::= */
162485	{sqlite3VtabArgInit(pParse);}
162486	break;
	@@ -162489,180 +162653,180 @@
162489	case 297: /* lp ::= LP */ yytestcase(yyruleno==297);
162490	{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
162491	break;
162492	case 298: /* with ::= WITH wqlist */
162493	case 299: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==299);
162494	{ sqlite3WithPush(pParse, yymsp[0].minor.yy195, 1); }
162495	break;
162496	case 300: /* wqas ::= AS */
162497	{yymsp[0].minor.yy570 = M10d_Any;}
162498	break;
162499	case 301: /* wqas ::= AS MATERIALIZED */
162500	{yymsp[-1].minor.yy570 = M10d_Yes;}
162501	break;
162502	case 302: /* wqas ::= AS NOT MATERIALIZED */
162503	{yymsp[-2].minor.yy570 = M10d_No;}
162504	break;
162505	case 303: /* wqitem ::= nm eidlist_opt wqas LP select RP */
162506	{
162507	yymsp[-5].minor.yy607 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy338, yymsp[-1].minor.yy307, yymsp[-3].minor.yy570); /A-overwrites-X/
162508	}
162509	break;
162510	case 304: /* wqlist ::= wqitem */
162511	{
162512	yymsp[0].minor.yy195 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy607); /A-overwrites-X/
162513	}
162514	break;
162515	case 305: /* wqlist ::= wqlist COMMA wqitem */
162516	{
162517	yymsp[-2].minor.yy195 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy195, yymsp[0].minor.yy607);
162518	}
162519	break;
162520	case 306: /* windowdefn_list ::= windowdefn */
162521	{ yylhsminor.yy19 = yymsp[0].minor.yy19; }
162522	yymsp[0].minor.yy19 = yylhsminor.yy19;
162523	break;
162524	case 307: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
162525	{
162526	assert( yymsp[0].minor.yy19!=0 );
162527	sqlite3WindowChain(pParse, yymsp[0].minor.yy19, yymsp[-2].minor.yy19);
162528	yymsp[0].minor.yy19->pNextWin = yymsp[-2].minor.yy19;
162529	yylhsminor.yy19 = yymsp[0].minor.yy19;
162530	}
162531	yymsp[-2].minor.yy19 = yylhsminor.yy19;
162532	break;
162533	case 308: /* windowdefn ::= nm AS LP window RP */
162534	{
162535	if( ALWAYS(yymsp[-1].minor.yy19) ){
162536	yymsp[-1].minor.yy19->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
162537	}
162538	yylhsminor.yy19 = yymsp[-1].minor.yy19;
162539	}
162540	yymsp[-4].minor.yy19 = yylhsminor.yy19;
162541	break;
162542	case 309: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
162543	{
162544	yymsp[-4].minor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, yymsp[-2].minor.yy338, yymsp[-1].minor.yy338, 0);
162545	}
162546	break;
162547	case 310: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
162548	{
162549	yylhsminor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, yymsp[-2].minor.yy338, yymsp[-1].minor.yy338, &yymsp[-5].minor.yy0);
162550	}
162551	yymsp[-5].minor.yy19 = yylhsminor.yy19;
162552	break;
162553	case 311: /* window ::= ORDER BY sortlist frame_opt */
162554	{
162555	yymsp[-3].minor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, 0, yymsp[-1].minor.yy338, 0);
162556	}
162557	break;
162558	case 312: /* window ::= nm ORDER BY sortlist frame_opt */
162559	{
162560	yylhsminor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, 0, yymsp[-1].minor.yy338, &yymsp[-4].minor.yy0);
162561	}
162562	yymsp[-4].minor.yy19 = yylhsminor.yy19;
162563	break;
162564	case 313: /* window ::= frame_opt */
162565	case 332: /* filter_over ::= over_clause */ yytestcase(yyruleno==332);
162566	{
162567	yylhsminor.yy19 = yymsp[0].minor.yy19;
162568	}
162569	yymsp[0].minor.yy19 = yylhsminor.yy19;
162570	break;
162571	case 314: /* window ::= nm frame_opt */
162572	{
162573	yylhsminor.yy19 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy19, 0, 0, &yymsp[-1].minor.yy0);
162574	}
162575	yymsp[-1].minor.yy19 = yylhsminor.yy19;
162576	break;
162577	case 315: /* frame_opt ::= */
162578	{
162579	yymsp[1].minor.yy19 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
162580	}
162581	break;
162582	case 316: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
162583	{
162584	yylhsminor.yy19 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy60, yymsp[-1].minor.yy113.eType, yymsp[-1].minor.yy113.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy570);
162585	}
162586	yymsp[-2].minor.yy19 = yylhsminor.yy19;
162587	break;
162588	case 317: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
162589	{
162590	yylhsminor.yy19 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy60, yymsp[-3].minor.yy113.eType, yymsp[-3].minor.yy113.pExpr, yymsp[-1].minor.yy113.eType, yymsp[-1].minor.yy113.pExpr, yymsp[0].minor.yy570);
162591	}
162592	yymsp[-5].minor.yy19 = yylhsminor.yy19;
162593	break;
162594	case 319: /* frame_bound_s ::= frame_bound */
162595	case 321: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==321);
162596	{yylhsminor.yy113 = yymsp[0].minor.yy113;}
162597	yymsp[0].minor.yy113 = yylhsminor.yy113;
162598	break;
162599	case 320: /* frame_bound_s ::= UNBOUNDED PRECEDING */
162600	case 322: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==322);
162601	case 324: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==324);
162602	{yylhsminor.yy113.eType = yymsp[-1].major; yylhsminor.yy113.pExpr = 0;}
162603	yymsp[-1].minor.yy113 = yylhsminor.yy113;
162604	break;
162605	case 323: /* frame_bound ::= expr PRECEDING\|FOLLOWING */
162606	{yylhsminor.yy113.eType = yymsp[0].major; yylhsminor.yy113.pExpr = yymsp[-1].minor.yy602;}
162607	yymsp[-1].minor.yy113 = yylhsminor.yy113;
162608	break;
162609	case 325: /* frame_exclude_opt ::= */
162610	{yymsp[1].minor.yy570 = 0;}
162611	break;
162612	case 326: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
162613	{yymsp[-1].minor.yy570 = yymsp[0].minor.yy570;}
162614	break;
162615	case 327: /* frame_exclude ::= NO OTHERS */
162616	case 328: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==328);
162617	{yymsp[-1].minor.yy570 = yymsp[-1].major; /A-overwrites-X/}
162618	break;
162619	case 329: /* frame_exclude ::= GROUP\|TIES */
162620	{yymsp[0].minor.yy570 = yymsp[0].major; /A-overwrites-X/}
162621	break;
162622	case 330: /* window_clause ::= WINDOW windowdefn_list */
162623	{ yymsp[-1].minor.yy19 = yymsp[0].minor.yy19; }
162624	break;
162625	case 331: /* filter_over ::= filter_clause over_clause */
162626	{
162627	if( yymsp[0].minor.yy19 ){
162628	yymsp[0].minor.yy19->pFilter = yymsp[-1].minor.yy602;
162629	}else{
162630	sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy602);
162631	}
162632	yylhsminor.yy19 = yymsp[0].minor.yy19;
162633	}
162634	yymsp[-1].minor.yy19 = yylhsminor.yy19;
162635	break;
162636	case 333: /* filter_over ::= filter_clause */
162637	{
162638	yylhsminor.yy19 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
162639	if( yylhsminor.yy19 ){
162640	yylhsminor.yy19->eFrmType = TK_FILTER;
162641	yylhsminor.yy19->pFilter = yymsp[0].minor.yy602;
162642	}else{
162643	sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy602);
162644	}
162645	}
162646	yymsp[0].minor.yy19 = yylhsminor.yy19;
162647	break;
162648	case 334: /* over_clause ::= OVER LP window RP */
162649	{
162650	yymsp[-3].minor.yy19 = yymsp[-1].minor.yy19;
162651	assert( yymsp[-3].minor.yy19!=0 );
162652	}
162653	break;
162654	case 335: /* over_clause ::= OVER nm */
162655	{
162656	yymsp[-1].minor.yy19 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
162657	if( yymsp[-1].minor.yy19 ){
162658	yymsp[-1].minor.yy19->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
162659	}
162660	}
162661	break;
162662	case 336: /* filter_clause ::= FILTER LP WHERE expr RP */
162663	{ yymsp[-4].minor.yy602 = yymsp[-1].minor.yy602; }
162664	break;
162665	default:
162666	/* (337) input ::= cmdlist */ yytestcase(yyruleno==337);
162667	/* (338) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==338);
162668	/* (339) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=339);
	@@ -191338,12 +191502,12 @@
191338	if( pStr->zBuf==0 ){
191339	jsonInit(pStr, ctx);
191340	jsonAppendChar(pStr, '{');
191341	}else if( pStr->nUsed>1 ){
191342	jsonAppendChar(pStr, ',');
191343	pStr->pCtx = ctx;
191344	}

191345	z = (const char*)sqlite3_value_text(argv[0]);
191346	n = (u32)sqlite3_value_bytes(argv[0]);
191347	jsonAppendString(pStr, z, n);
191348	jsonAppendChar(pStr, ':');
191349	jsonAppendValue(pStr, argv[1]);
	@@ -208318,17 +208482,33 @@
208318	** If not, use sqlite3_realloc() to grow the buffer so that there is.
208319	**
208320	** If successful, return zero. Otherwise, if an OOM condition is encountered,
208321	** set *pRc to SQLITE_NOMEM and return non-zero.
208322	*/
208323	static int sessionBufferGrow(SessionBuffer p, size_t nByte, int pRc){
208324	if( *pRc==SQLITE_OK && (size_t)(p->nAlloc-p->nBuf)<nByte ){


208325	u8 *aNew;
208326	i64 nNew = p->nAlloc ? p->nAlloc : 128;

208327	do {
208328	nNew = nNew*2;
208329	}while( (size_t)(nNew-p->nBuf)<nByte );













208330
208331	aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
208332	if( 0==aNew ){
208333	*pRc = SQLITE_NOMEM;
208334	}else{
	@@ -229418,17 +229598,19 @@
229418	}
229419	if( iBest<0 ) break;
229420
229421	nInst++;
229422	if( nInst>=pCsr->nInstAlloc ){
229423	pCsr->nInstAlloc = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
229424	aInst = (int*)sqlite3_realloc64(
229425	pCsr->aInst, pCsr->nInstAllocsizeof(int)3
229426	);
229427	if( aInst ){
229428	pCsr->aInst = aInst;

229429	}else{

229430	rc = SQLITE_NOMEM;
229431	break;
229432	}
229433	}
229434
	@@ -230259,11 +230441,11 @@
230259	int nArg, /* Number of args */
230260	sqlite3_value *apUnused / Function arguments */
230261	){
230262	assert( nArg==0 );
230263	UNUSED_PARAM2(nArg, apUnused);
230264	sqlite3_result_text(pCtx, "fts5: 2021-05-14 15:37:00 cf63abbe559d04f993f99a37d41ba4a97c0261094f1d4cc05cfa23b1e11731f5", -1, SQLITE_TRANSIENT);
230265	}
230266
230267	/*
230268	** Return true if zName is the extension on one of the shadow tables used
230269	** by this module.
	@@ -235185,12 +235367,12 @@
235185	}
235186	#endif /* SQLITE_CORE */
235187	#endif /* !defined(SQLITE_CORE) \|\| defined(SQLITE_ENABLE_STMTVTAB) */
235188
235189	/************ End of stmt.c **********************************************/
235190	#if __LINE__!=235190
235191	#undef SQLITE_SOURCE_ID
235192	#define SQLITE_SOURCE_ID "2021-05-17 17:14:38 ace12a3912a4fdc2f0e741361ec705652a11b6f5e3548d54bd6f273671baalt2"
235193	#endif
235194	/* Return the source-id for this library */
235195	SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
235196	/************************ End of sqlite3.c ****************************/
235197

	--- src/sqlite3.c
	+++ src/sqlite3.c
	@@ -81,12 +81,14 @@
81	"4_BYTE_ALIGNED_MALLOC",
82	#endif
83	#if SQLITE_64BIT_STATS
84	"64BIT_STATS",
85	#endif
86	#ifdef SQLITE_ALLOW_COVERING_INDEX_SCAN
87	# if SQLITE_ALLOW_COVERING_INDEX_SCAN != 1
88	"ALLOW_COVERING_INDEX_SCAN=" CTIMEOPT_VAL(SQLITE_ALLOW_COVERING_INDEX_SCAN),
89	# endif
90	#endif
91	#if SQLITE_ALLOW_URI_AUTHORITY
92	"ALLOW_URI_AUTHORITY",
93	#endif
94	#ifdef SQLITE_BITMASK_TYPE
	@@ -144,12 +146,14 @@
146	"DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
147	#endif
148	#ifdef SQLITE_DEFAULT_LOOKASIDE
149	"DEFAULT_LOOKASIDE=" CTIMEOPT_VAL2(SQLITE_DEFAULT_LOOKASIDE),
150	#endif
151	#ifdef SQLITE_DEFAULT_MEMSTATUS
152	# if SQLITE_DEFAULT_MEMSTATUS != 1
153	"DEFAULT_MEMSTATUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_MEMSTATUS),
154	# endif
155	#endif
156	#ifdef SQLITE_DEFAULT_MMAP_SIZE
157	"DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),
158	#endif
159	#ifdef SQLITE_DEFAULT_PAGE_SIZE
	@@ -219,11 +223,11 @@
223	"ENABLE_BATCH_ATOMIC_WRITE",
224	#endif
225	#if SQLITE_ENABLE_BYTECODE_VTAB
226	"ENABLE_BYTECODE_VTAB",
227	#endif
228	#ifdef SQLITE_ENABLE_CEROD
229	"ENABLE_CEROD=" CTIMEOPT_VAL(SQLITE_ENABLE_CEROD),
230	#endif
231	#if SQLITE_ENABLE_COLUMN_METADATA
232	"ENABLE_COLUMN_METADATA",
233	#endif
	@@ -233,22 +237,22 @@
237	#if SQLITE_ENABLE_COSTMULT
238	"ENABLE_COSTMULT",
239	#endif
240	#if SQLITE_ENABLE_CURSOR_HINTS
241	"ENABLE_CURSOR_HINTS",
242	#endif
243	#if SQLITE_ENABLE_DBPAGE_VTAB
244	"ENABLE_DBPAGE_VTAB",
245	#endif
246	#if SQLITE_ENABLE_DBSTAT_VTAB
247	"ENABLE_DBSTAT_VTAB",
248	#endif
249	#if SQLITE_ENABLE_EXPENSIVE_ASSERT
250	"ENABLE_EXPENSIVE_ASSERT",
251	#endif
252	#if SQLITE_ENABLE_EXPLAIN_COMMENTS
253	"ENABLE_EXPLAIN_COMMENTS",



254	#endif
255	#if SQLITE_ENABLE_FTS3
256	"ENABLE_FTS3",
257	#endif
258	#if SQLITE_ENABLE_FTS3_PARENTHESIS
	@@ -302,10 +306,13 @@
306	#if SQLITE_ENABLE_NORMALIZE
307	"ENABLE_NORMALIZE",
308	#endif
309	#if SQLITE_ENABLE_NULL_TRIM
310	"ENABLE_NULL_TRIM",
311	#endif
312	#if SQLITE_ENABLE_OFFSET_SQL_FUNC
313	"ENABLE_OFFSET_SQL_FUNC",
314	#endif
315	#if SQLITE_ENABLE_OVERSIZE_CELL_CHECK
316	"ENABLE_OVERSIZE_CELL_CHECK",
317	#endif
318	#if SQLITE_ENABLE_PREUPDATE_HOOK
	@@ -333,11 +340,11 @@
340	"ENABLE_SORTER_REFERENCES",
341	#endif
342	#if SQLITE_ENABLE_SQLLOG
343	"ENABLE_SQLLOG",
344	#endif
345	#if SQLITE_ENABLE_STAT4
346	"ENABLE_STAT4",
347	#endif
348	#if SQLITE_ENABLE_STMTVTAB
349	"ENABLE_STMTVTAB",
350	#endif
	@@ -387,12 +394,14 @@
394	"FTS5_NO_WITHOUT_ROWID",
395	#endif
396	#if HAVE_ISNAN \|\| SQLITE_HAVE_ISNAN
397	"HAVE_ISNAN",
398	#endif
399	#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
400	# if SQLITE_HOMEGROWN_RECURSIVE_MUTEX != 1
401	"HOMEGROWN_RECURSIVE_MUTEX=" CTIMEOPT_VAL(SQLITE_HOMEGROWN_RECURSIVE_MUTEX),
402	# endif
403	#endif
404	#if SQLITE_IGNORE_AFP_LOCK_ERRORS
405	"IGNORE_AFP_LOCK_ERRORS",
406	#endif
407	#if SQLITE_IGNORE_FLOCK_LOCK_ERRORS
	@@ -486,13 +495,10 @@
495	"MMAP_READWRITE",
496	#endif
497	#if SQLITE_MUTEX_NOOP
498	"MUTEX_NOOP",
499	#endif



500	#if SQLITE_MUTEX_OMIT
501	"MUTEX_OMIT",
502	#endif
503	#if SQLITE_MUTEX_PTHREADS
504	"MUTEX_PTHREADS",
	@@ -558,18 +564,21 @@
564	"OMIT_CONFLICT_CLAUSE",
565	#endif
566	#if SQLITE_OMIT_CTE
567	"OMIT_CTE",
568	#endif
569	#if defined(SQLITE_OMIT_DATETIME_FUNCS) \|\| defined(SQLITE_OMIT_FLOATING_POINT)
570	"OMIT_DATETIME_FUNCS",
571	#endif
572	#if SQLITE_OMIT_DECLTYPE
573	"OMIT_DECLTYPE",
574	#endif
575	#if SQLITE_OMIT_DEPRECATED
576	"OMIT_DEPRECATED",
577	#endif
578	#if SQLITE_OMIT_DESERIALIZE
579	"OMIT_DESERIALIZE",
580	#endif
581	#if SQLITE_OMIT_DISKIO
582	"OMIT_DISKIO",
583	#endif
584	#if SQLITE_OMIT_EXPLAIN
	@@ -593,10 +602,13 @@
602	#if SQLITE_OMIT_INCRBLOB
603	"OMIT_INCRBLOB",
604	#endif
605	#if SQLITE_OMIT_INTEGRITY_CHECK
606	"OMIT_INTEGRITY_CHECK",
607	#endif
608	#if SQLITE_OMIT_INTROSPECTION_PRAGMAS
609	"OMIT_INTROSPECTION_PRAGMAS",
610	#endif
611	#if SQLITE_OMIT_LIKE_OPTIMIZATION
612	"OMIT_LIKE_OPTIMIZATION",
613	#endif
614	#if SQLITE_OMIT_LOAD_EXTENSION
	@@ -657,12 +669,14 @@
669	"OMIT_TEMPDB",
670	#endif
671	#if SQLITE_OMIT_TEST_CONTROL
672	"OMIT_TEST_CONTROL",
673	#endif
674	#ifdef SQLITE_OMIT_TRACE
675	# if SQLITE_OMIT_TRACE != 1
676	"OMIT_TRACE=" CTIMEOPT_VAL(SQLITE_OMIT_TRACE),
677	# endif
678	#endif
679	#if SQLITE_OMIT_TRIGGER
680	"OMIT_TRIGGER",
681	#endif
682	#if SQLITE_OMIT_TRUNCATE_OPTIMIZATION
	@@ -693,12 +707,14 @@
707	"PCACHE_SEPARATE_HEADER",
708	#endif
709	#if SQLITE_PERFORMANCE_TRACE
710	"PERFORMANCE_TRACE",
711	#endif
712	#ifdef SQLITE_POWERSAFE_OVERWRITE
713	# if SQLITE_POWERSAFE_OVERWRITE != 1
714	"POWERSAFE_OVERWRITE=" CTIMEOPT_VAL(SQLITE_POWERSAFE_OVERWRITE),
715	# endif
716	#endif
717	#if SQLITE_PREFER_PROXY_LOCKING
718	"PREFER_PROXY_LOCKING",
719	#endif
720	#if SQLITE_PROXY_DEBUG
	@@ -729,11 +745,14 @@
745	"STMTJRNL_SPILL=" CTIMEOPT_VAL(SQLITE_STMTJRNL_SPILL),
746	#endif
747	#if SQLITE_SUBSTR_COMPATIBILITY
748	"SUBSTR_COMPATIBILITY",
749	#endif
750	#if (!defined(SQLITE_WIN32_MALLOC) \
751	&& !defined(SQLITE_ZERO_MALLOC) \
752	&& !defined(SQLITE_MEMDEBUG) \
753	) \|\| defined(SQLITE_SYSTEM_MALLOC)
754	"SYSTEM_MALLOC",
755	#endif
756	#if SQLITE_TCL
757	"TCL",
758	#endif
	@@ -1186,11 +1205,11 @@
1205	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
1206	** [sqlite_version()] and [sqlite_source_id()].
1207	*/
1208	#define SQLITE_VERSION "3.36.0"
1209	#define SQLITE_VERSION_NUMBER 3036000
1210	#define SQLITE_SOURCE_ID "2021-06-03 18:56:42 4a587c3492faa99490fd67ca1de9fceafcdc12d220f42817791923be258b73f1"
1211
1212	/*
1213	** CAPI3REF: Run-Time Library Version Numbers
1214	** KEYWORDS: sqlite3_version sqlite3_sourceid
1215	**
	@@ -14310,12 +14329,13 @@
14329	#define TK_VECTOR 176
14330	#define TK_SELECT_COLUMN 177
14331	#define TK_IF_NULL_ROW 178
14332	#define TK_ASTERISK 179
14333	#define TK_SPAN 180
14334	#define TK_ERROR 181
14335	#define TK_SPACE 182
14336	#define TK_ILLEGAL 183
14337
14338	/************ End of parse.h *********************************************/
14339	/************ Continuing where we left off in sqliteInt.h ****************/
14340	#include <stdio.h>
14341	#include <stdlib.h>
	@@ -16006,11 +16026,11 @@
16026	/* 152 */ 0x10, 0x10, 0x00, 0x04, 0x1a, 0x00, 0x00, 0x00,\
16027	/* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
16028	/* 168 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
16029	/* 176 */ 0x00, 0x00, 0x00, 0x00,}
16030
16031	/* The resolve3P2Values() routine is able to run faster if it knows
16032	** the value of the largest JUMP opcode. The smaller the maximum
16033	** JUMP opcode the better, so the mkopcodeh.tcl script that
16034	** generated this include file strives to group all JUMP opcodes
16035	** together near the beginning of the list.
16036	*/
	@@ -18511,10 +18531,11 @@
18531	unsigned isCorrelated :1; /* True if sub-query is correlated */
18532	unsigned viaCoroutine :1; /* Implemented as a co-routine */
18533	unsigned isRecursive :1; /* True for recursive reference in WITH */
18534	unsigned fromDDL :1; /* Comes from sqlite_schema */
18535	unsigned isCte :1; /* This is a CTE */
18536	unsigned notCte :1; /* This item may not match a CTE */
18537	} fg;
18538	int iCursor; /* The VDBE cursor number used to access this table */
18539	Expr pOn; / The ON clause of a join */
18540	IdList pUsing; / The USING clause of a join */
18541	Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */
	@@ -19488,10 +19509,11 @@
19509	** An instance of the With object represents a WITH clause containing
19510	** one or more CTEs (common table expressions).
19511	*/
19512	struct With {
19513	int nCte; /* Number of CTEs in the WITH clause */
19514	int bView; /* Belongs to the outermost Select of a view */
19515	With pOuter; / Containing WITH clause, or NULL */
19516	Cte a[1]; /* For each CTE in the WITH clause.... */
19517	};
19518
19519	/*
	@@ -19880,10 +19902,11 @@
19902	SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3*);
19903	SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3*,int);
19904	SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3*);
19905	SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
19906	SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3,Table);
19907	SQLITE_PRIVATE void sqlite3GenerateColumnNames(Parse pParse, Select pSelect);
19908	SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse,ExprList,i16,Column*);
19909	SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(Parse,Table,Select*,char);
19910	SQLITE_PRIVATE Table sqlite3ResultSetOfSelect(Parse,Select*,char);
19911	SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *, int);
19912	SQLITE_PRIVATE Index sqlite3PrimaryKeyIndex(Table);
	@@ -27891,11 +27914,10 @@
27914	SQLITE_PRIVATE int sqlite3MallocInit(void){
27915	int rc;
27916	if( sqlite3GlobalConfig.m.xMalloc==0 ){
27917	sqlite3MemSetDefault();
27918	}

27919	mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
27920	if( sqlite3GlobalConfig.pPage==0 \|\| sqlite3GlobalConfig.szPage<512
27921	\|\| sqlite3GlobalConfig.nPage<=0 ){
27922	sqlite3GlobalConfig.pPage = 0;
27923	sqlite3GlobalConfig.szPage = 0;
	@@ -30588,10 +30610,18 @@
30610	}
30611	case TK_IF_NULL_ROW: {
30612	sqlite3TreeViewLine(pView, "IF-NULL-ROW %d", pExpr->iTable);
30613	sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
30614	break;
30615	}
30616	case TK_ERROR: {
30617	Expr tmp;
30618	sqlite3TreeViewLine(pView, "ERROR");
30619	tmp = *pExpr;
30620	tmp.op = pExpr->op2;
30621	sqlite3TreeViewExpr(pView, &tmp, 0);
30622	break;
30623	}
30624	default: {
30625	sqlite3TreeViewLine(pView, "op=%d", pExpr->op);
30626	break;
30627	}
	@@ -42058,10 +42088,26 @@
42088	/* Register all VFSes defined in the aVfs[] array */
42089	for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
42090	sqlite3_vfs_register(&aVfs[i], i==0);
42091	}
42092	unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
42093
42094	/* Validate lock assumptions */
42095	assert( SQLITE_SHM_NLOCK==8 ); /* Number of available locks */
42096	assert( UNIX_SHM_BASE==120 ); /* Start of locking area */
42097	/* Locks:
42098	** WRITE UNIX_SHM_BASE 120
42099	** CKPT UNIX_SHM_BASE+1 121
42100	** RECOVER UNIX_SHM_BASE+2 122
42101	** READ-0 UNIX_SHM_BASE+3 123
42102	** READ-1 UNIX_SHM_BASE+4 124
42103	** READ-2 UNIX_SHM_BASE+5 125
42104	** READ-3 UNIX_SHM_BASE+6 126
42105	** READ-4 UNIX_SHM_BASE+7 127
42106	** DMS UNIX_SHM_BASE+8 128
42107	*/
42108	assert( UNIX_SHM_DMS==128 ); /* Byte offset of the deadman-switch */
42109	return SQLITE_OK;
42110	}
42111
42112	/*
42113	** Shutdown the operating system interface.
	@@ -48523,16 +48569,16 @@
48569	MemStore pStore; / The storage */
48570	int eLock; /* Most recent lock against this file */
48571	};
48572
48573	/*
48574	** File-scope variables for holding the memdb files that are accessible
48575	** to multiple database connections in separate threads.
48576	**
48577	** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object.
48578	*/
48579	static struct MemFS {
48580	int nMemStore; /* Number of shared MemStore objects */
48581	MemStore *apMemStore; / Array of all shared MemStore objects */
48582	} memdb_g;
48583
48584	/*
	@@ -74858,12 +74904,12 @@
74904	if( rc ) goto cleardatabasepage_out;
74905	}
74906	if( !pPage->leaf ){
74907	rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
74908	if( rc ) goto cleardatabasepage_out;
74909	}
74910	if( pnChange ){
74911	testcase( !pPage->intKey );
74912	*pnChange += pPage->nCell;
74913	}
74914	if( freePageFlag ){
74915	freePage(pPage, &rc);
	@@ -74884,13 +74930,12 @@
74930	**
74931	** This routine will fail with SQLITE_LOCKED if there are any open
74932	** read cursors on the table. Open write cursors are moved to the
74933	** root of the table.
74934	**
74935	** If pnChange is not NULL, then the integer value pointed to by pnChange
74936	** is incremented by the number of entries in the table.

74937	*/
74938	SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree p, int iTable, int pnChange){
74939	int rc;
74940	BtShared *pBt = p->pBt;
74941	sqlite3BtreeEnter(p);
	@@ -86924,11 +86969,11 @@
86969	printf(" <== R[%d]", (int)(p->pScopyFrom - &p[-iReg]));
86970	}
86971	printf("\n");
86972	sqlite3VdbeCheckMemInvariants(p);
86973	}
86974	/*/ void sqlite3PrintMem(Mem pMem){
86975	memTracePrint(pMem);
86976	printf("\n");
86977	fflush(stdout);
86978	}
86979	#endif
	@@ -88466,11 +88511,11 @@
88511	pIn1 = &aMem[pOp->p1];
88512	pIn3 = &aMem[pOp->p3];
88513	flags1 = pIn1->flags;
88514	flags3 = pIn3->flags;
88515	if( (flags1 & flags3 & MEM_Int)!=0 ){
88516	assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT \|\| CORRUPT_DB );
88517	/* Common case of comparison of two integers */
88518	if( pIn3->u.i > pIn1->u.i ){
88519	iCompare = +1;
88520	if( sqlite3aGTb[pOp->opcode] ){
88521	VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);
	@@ -92663,15 +92708,14 @@
92708	**
92709	** The table being clear is in the main database file if P2==0. If
92710	** P2==1 then the table to be clear is in the auxiliary database file
92711	** that is used to store tables create using CREATE TEMPORARY TABLE.
92712	**
92713	** If the P3 value is non-zero, then the row change count is incremented
92714	** by the number of rows in the table being cleared. If P3 is greater
92715	** than zero, then the value stored in register P3 is also incremented
92716	** by the number of rows in the table being cleared.

92717	**
92718	** See also: Destroy
92719	*/
92720	case OP_Clear: {
92721	int nChange;
	@@ -92678,13 +92722,11 @@
92722
92723	sqlite3VdbeIncrWriteCounter(p, 0);
92724	nChange = 0;
92725	assert( p->readOnly==0 );
92726	assert( DbMaskTest(p->btreeMask, pOp->p2) );
92727	rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, (u32)pOp->p1, &nChange);


92728	if( pOp->p3 ){
92729	p->nChange += nChange;
92730	if( pOp->p3>0 ){
92731	assert( memIsValid(&aMem[pOp->p3]) );
92732	memAboutToChange(p, &aMem[pOp->p3]);
	@@ -93668,10 +93710,11 @@
93710
93711	pBt = db->aDb[pOp->p1].pBt;
93712	pPager = sqlite3BtreePager(pBt);
93713	eOld = sqlite3PagerGetJournalMode(pPager);
93714	if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;
93715	assert( sqlite3BtreeHoldsMutex(pBt) );
93716	if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
93717
93718	#ifndef SQLITE_OMIT_WAL
93719	zFilename = sqlite3PagerFilename(pPager, 1);
93720
	@@ -98688,30 +98731,32 @@
98731	/*
98732	** Truncate the in-memory file.
98733	*/
98734	static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
98735	MemJournal p = (MemJournal )pJfd;
98736	assert( p->endpoint.pChunk==0 \|\| p->endpoint.pChunk->pNext==0 );
98737	if( size<p->endpoint.iOffset ){
98738	FileChunk *pIter = 0;
98739	if( size==0 ){
98740	memjrnlFreeChunks(p->pFirst);
98741	p->pFirst = 0;
98742	}else{
98743	i64 iOff = p->nChunkSize;
98744	for(pIter=p->pFirst; ALWAYS(pIter) && iOff<=size; pIter=pIter->pNext){
98745	iOff += p->nChunkSize;
98746	}
98747	if( ALWAYS(pIter) ){
98748	memjrnlFreeChunks(pIter->pNext);
98749	pIter->pNext = 0;
98750	}
98751	}
98752
98753	p->endpoint.pChunk = pIter;
98754	p->endpoint.iOffset = size;
98755	p->readpoint.pChunk = 0;
98756	p->readpoint.iOffset = 0;
98757	}
98758	return SQLITE_OK;
98759	}
98760
98761	/*
98762	** Close the file.
	@@ -100390,11 +100435,11 @@
100435	nc.uNC.pEList = pEList;
100436	nc.ncFlags = NC_AllowAgg\|NC_UEList\|NC_NoSelect;
100437	nc.nNcErr = 0;
100438	db = pParse->db;
100439	savedSuppErr = db->suppressErr;
100440	db->suppressErr = 1;
100441	rc = sqlite3ResolveExprNames(&nc, pE);
100442	db->suppressErr = savedSuppErr;
100443	if( rc ) return 0;
100444
100445	/* Try to match the ORDER BY expression against an expression
	@@ -100489,33 +100534,28 @@
100534	** expression, resolving any symbols in it, and then comparing
100535	** it against each expression returned by the SELECT statement.
100536	** Once the comparisons are finished, the duplicate expression
100537	** is deleted.
100538	**
100539	** If this is running as part of an ALTER TABLE operation and
100540	** the symbols resolve successfully, also resolve the symbols in the
100541	** actual expression. This allows the code in alter.c to modify
100542	** column references within the ORDER BY expression as required. */
100543	pDup = sqlite3ExprDup(db, pE, 0);






100544	if( !db->mallocFailed ){
100545	assert(pDup);
100546	iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
100547	if( IN_RENAME_OBJECT && iCol>0 ){
100548	resolveOrderByTermToExprList(pParse, pSelect, pE);
100549	}
100550	}
100551	sqlite3ExprDelete(db, pDup);


100552	}
100553	}
100554	if( iCol>0 ){
100555	/* Convert the ORDER BY term into an integer column number iCol,
100556	** taking care to preserve the COLLATE clause if it exists. */
100557	if( !IN_RENAME_OBJECT ){
100558	Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
100559	if( pNew==0 ) return 1;
100560	pNew->flags \|= EP_IntValue;
100561	pNew->u.iValue = iCol;
	@@ -101595,11 +101635,11 @@
101635	** just the expression for the i-th term of the result set, and may
101636	** not be ready for evaluation because the table cursor has not yet
101637	** been positioned.
101638	*/
101639	SQLITE_PRIVATE Expr sqlite3VectorFieldSubexpr(Expr pVector, int i){
101640	assert( i<sqlite3ExprVectorSize(pVector) \|\| pVector->op==TK_ERROR );
101641	if( sqlite3ExprIsVector(pVector) ){
101642	assert( pVector->op2==0 \|\| pVector->op==TK_REGISTER );
101643	if( pVector->op==TK_SELECT \|\| pVector->op2==TK_SELECT ){
101644	return pVector->x.pSelect->pEList->a[i].pExpr;
101645	}else{
	@@ -101711,21 +101751,24 @@
101751	int regSelect, /* First in array of registers */
101752	Expr *ppExpr, / OUT: Expression element */
101753	int pRegFree / OUT: Temp register to free */
101754	){
101755	u8 op = pVector->op;
101756	assert( op==TK_VECTOR \|\| op==TK_REGISTER \|\| op==TK_SELECT \|\| op==TK_ERROR );
101757	if( op==TK_REGISTER ){
101758	*ppExpr = sqlite3VectorFieldSubexpr(pVector, iField);
101759	return pVector->iTable+iField;
101760	}
101761	if( op==TK_SELECT ){
101762	*ppExpr = pVector->x.pSelect->pEList->a[iField].pExpr;
101763	return regSelect+iField;
101764	}
101765	if( op==TK_VECTOR ){
101766	*ppExpr = pVector->x.pList->a[iField].pExpr;
101767	return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree);
101768	}
101769	return 0;
101770	}
101771
101772	/*
101773	** Expression pExpr is a comparison between two vector values. Compute
101774	** the result of the comparison (1, 0, or NULL) and write that
	@@ -102658,11 +102701,12 @@
102701	&& pOldExpr->op==TK_SELECT_COLUMN
102702	&& (pNewExpr = pItem->pExpr)!=0
102703	){
102704	assert( pNewExpr->iColumn==0 \|\| i>0 );
102705	if( pNewExpr->iColumn==0 ){
102706	assert( pOldExpr->pLeft==pOldExpr->pRight
102707	\|\| ExprHasProperty(pOldExpr->pLeft, EP_Subquery) );
102708	pPriorSelectCol = pNewExpr->pLeft = pNewExpr->pRight;
102709	}else{
102710	assert( i>0 );
102711	assert( pItem[-1].pExpr!=0 );
102712	assert( pNewExpr->iColumn==pItem[-1].pExpr->iColumn+1 );
	@@ -104131,23 +104175,27 @@
104175	addrOnce?"":"CORRELATED ", pSelect->selId
104176	));
104177	/* If the LHS and RHS of the IN operator do not match, that
104178	** error will have been caught long before we reach this point. */
104179	if( ALWAYS(pEList->nExpr==nVal) ){
104180	Select *pCopy;
104181	SelectDest dest;
104182	int i;
104183	int rc;
104184	sqlite3SelectDestInit(&dest, SRT_Set, iTab);
104185	dest.zAffSdst = exprINAffinity(pParse, pExpr);
104186	pSelect->iLimit = 0;
104187	testcase( pSelect->selFlags & SF_Distinct );
104188	testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
104189	pCopy = sqlite3SelectDup(pParse->db, pSelect, 0);
104190	rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest);
104191	sqlite3SelectDelete(pParse->db, pCopy);
104192	sqlite3DbFree(pParse->db, dest.zAffSdst);
104193	if( rc ){
104194	sqlite3KeyInfoUnref(pKeyInfo);
104195	return;
104196	}

104197	assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
104198	assert( pEList!=0 );
104199	assert( pEList->nExpr>0 );
104200	assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
104201	for(i=0; i<nVal; i++){
	@@ -104242,15 +104290,33 @@
104290	int nReg; /* Registers to allocate */
104291	Expr pLimit; / New limit expression */
104292
104293	Vdbe *v = pParse->pVdbe;
104294	assert( v!=0 );
104295	if( pParse->nErr ) return 0;
104296	testcase( pExpr->op==TK_EXISTS );
104297	testcase( pExpr->op==TK_SELECT );
104298	assert( pExpr->op==TK_EXISTS \|\| pExpr->op==TK_SELECT );
104299	assert( ExprHasProperty(pExpr, EP_xIsSelect) );
104300	pSel = pExpr->x.pSelect;
104301
104302	/* If this routine has already been coded, then invoke it as a
104303	** subroutine. */
104304	if( ExprHasProperty(pExpr, EP_Subrtn) ){
104305	ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId));
104306	sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
104307	pExpr->y.sub.iAddr);
104308	return pExpr->iTable;
104309	}
104310
104311	/* Begin coding the subroutine */
104312	ExprSetProperty(pExpr, EP_Subrtn);
104313	pExpr->y.sub.regReturn = ++pParse->nMem;
104314	pExpr->y.sub.iAddr =
104315	sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
104316	VdbeComment((v, "return address"));
104317
104318
104319	/* The evaluation of the EXISTS/SELECT must be repeated every time it
104320	** is encountered if any of the following is true:
104321	**
104322	** * The right-hand side is a correlated subquery
	@@ -104259,26 +104325,10 @@
104325	**
104326	** If all of the above are false, then we can run this code just once
104327	** save the results, and reuse the same result on subsequent invocations.
104328	*/
104329	if( !ExprHasProperty(pExpr, EP_VarSelect) ){
















104330	addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
104331	}
104332
104333	/* For a SELECT, generate code to put the values for all columns of
104334	** the first row into an array of registers and return the index of
	@@ -104323,23 +104373,26 @@
104373	pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1");
104374	pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0);
104375	}
104376	pSel->iLimit = 0;
104377	if( sqlite3Select(pParse, pSel, &dest) ){
104378	if( pParse->nErr ){
104379	pExpr->op2 = pExpr->op;
104380	pExpr->op = TK_ERROR;
104381	}
104382	return 0;
104383	}
104384	pExpr->iTable = rReg = dest.iSDParm;
104385	ExprSetVVAProperty(pExpr, EP_NoReduce);
104386	if( addrOnce ){
104387	sqlite3VdbeJumpHere(v, addrOnce);





104388	}
104389
104390	/* Subroutine return */
104391	sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
104392	sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
104393	sqlite3ClearTempRegCache(pParse);
104394	return rReg;
104395	}
104396	#endif /* SQLITE_OMIT_SUBQUERY */
104397
104398	#ifndef SQLITE_OMIT_SUBQUERY
	@@ -105166,11 +105219,11 @@
105219	default: {
105220	/* Make NULL the default case so that if a bug causes an illegal
105221	** Expr node to be passed into this function, it will be handled
105222	** sanely and not crash. But keep the assert() to bring the problem
105223	** to the attention of the developers. */
105224	assert( op==TK_NULL \|\| op==TK_ERROR \|\| pParse->db->mallocFailed );
105225	sqlite3VdbeAddOp2(v, OP_Null, 0, target);
105226	return target;
105227	}
105228	#ifndef SQLITE_OMIT_BLOB_LITERAL
105229	case TK_BLOB: {
	@@ -105509,11 +105562,12 @@
105562	case TK_SELECT_COLUMN: {
105563	int n;
105564	if( pExpr->pLeft->iTable==0 ){
105565	pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft);
105566	}
105567	assert( pExpr->iTable==0 \|\| pExpr->pLeft->op==TK_SELECT
105568	\|\| pExpr->pLeft->op==TK_ERROR );
105569	if( pExpr->iTable!=0
105570	&& pExpr->iTable!=(n = sqlite3ExprVectorSize(pExpr->pLeft))
105571	){
105572	sqlite3ErrorMsg(pParse, "%d columns assigned %d values",
105573	pExpr->iTable, n);
	@@ -107141,10 +107195,11 @@
107195	/* Check to see if pExpr is a duplicate of another aggregate
107196	** function that is already in the pAggInfo structure
107197	*/
107198	struct AggInfo_func *pItem = pAggInfo->aFunc;
107199	for(i=0; i<pAggInfo->nFunc; i++, pItem++){
107200	if( pItem->pFExpr==pExpr ) break;
107201	if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){
107202	break;
107203	}
107204	}
107205	if( i>=pAggInfo->nFunc ){
	@@ -108229,11 +108284,11 @@
108284	Parse *pParse,
108285	struct RenameCtx *pCtx,
108286	void *pPtr
108287	){
108288	RenameToken **pp;
108289	if( pPtr==0 ){
108290	return 0;
108291	}
108292	for(pp=&pParse->pRename; (pp); pp=&(pp)->pNext){
108293	if( (*pp)->p==pPtr ){
108294	RenameToken pToken = pp;
	@@ -111886,18 +111941,21 @@
111941	SrcList *pList = pSelect->pSrc;
111942
111943	if( NEVER(pList==0) ) return WRC_Continue;
111944	for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
111945	if( pFix->bTemp==0 ){
111946	if( pItem->zDatabase ){
111947	if( iDb!=sqlite3FindDbName(db, pItem->zDatabase) ){
111948	sqlite3ErrorMsg(pFix->pParse,
111949	"%s %T cannot reference objects in database %s",
111950	pFix->zType, pFix->pName, pItem->zDatabase);
111951	return WRC_Abort;
111952	}
111953	sqlite3DbFree(db, pItem->zDatabase);
111954	pItem->zDatabase = 0;
111955	pItem->fg.notCte = 1;
111956	}
111957	pItem->pSchema = pFix->pSchema;
111958	pItem->fg.fromDDL = 1;
111959	}
111960	#if !defined(SQLITE_OMIT_VIEW) \|\| !defined(SQLITE_OMIT_TRIGGER)
111961	if( sqlite3WalkExpr(&pFix->w, pList->a[i].pOn) ) return WRC_Abort;
	@@ -113178,11 +113236,11 @@
113236	if( iDb<0 ){
113237	sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
113238	return -1;
113239	}
113240	}else{
113241	assert( db->init.iDb==0 \|\| db->init.busy \|\| IN_SPECIAL_PARSE
113242	\|\| (db->mDbFlags & DBFLAG_Vacuum)!=0);
113243	iDb = db->init.iDb;
113244	*pUnqual = pName1;
113245	}
113246	return iDb;
	@@ -113360,10 +113418,11 @@
113418	static void sqlite3ForceNotReadOnly(Parse *pParse){
113419	int iReg = ++pParse->nMem;
113420	Vdbe *v = sqlite3GetVdbe(pParse);
113421	if( v ){
113422	sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY);
113423	sqlite3VdbeUsesBtree(v, 0);
113424	}
113425	}
113426
113427	/*
113428	** Begin constructing a new table representation in memory. This is
	@@ -118643,10 +118702,13 @@
118702	pTab->zName, P4_STATIC);
118703	}
118704	for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
118705	assert( pIdx->pSchema==pTab->pSchema );
118706	sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
118707	if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
118708	sqlite3VdbeChangeP3(v, -1, memCnt ? memCnt : -1);
118709	}
118710	}
118711	}else
118712	#endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
118713	{
118714	u16 wcf = WHERE_ONEPASS_DESIRED\|WHERE_DUPLICATES_OK;
	@@ -133883,11 +133945,11 @@
133945	**
133946	** full=ON, short=ANY: If the result refers directly to a table column,
133947	** then the result column name with the table name
133948	** prefix, ex: TABLE.COLUMN. Otherwise use zSpan.
133949	*/
133950	SQLITE_PRIVATE void sqlite3GenerateColumnNames(
133951	Parse pParse, / Parser context */
133952	Select pSelect / Generate column names for this SELECT statement */
133953	){
133954	Vdbe *v = pParse->pVdbe;
133955	int i;
	@@ -133973,11 +134035,11 @@
134035	** That is the only documented guarantee. However, countless applications
134036	** developed over the years have made baseless assumptions about column names
134037	** and will break if those assumptions changes. Hence, use extreme caution
134038	** when modifying this routine to avoid breaking legacy.
134039	**
134040	** See Also: sqlite3GenerateColumnNames()
134041	*/
134042	SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
134043	Parse pParse, / Parsing context */
134044	ExprList pEList, / Expr list from which to derive column names */
134045	i16 pnCol, / Write the number of columns here */
	@@ -134676,10 +134738,11 @@
134738	int nLimit = 0; /* Initialize to suppress harmless compiler warning */
134739	assert( !pPrior->pLimit );
134740	pPrior->iLimit = p->iLimit;
134741	pPrior->iOffset = p->iOffset;
134742	pPrior->pLimit = p->pLimit;
134743	SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL left...\n"));
134744	rc = sqlite3Select(pParse, pPrior, &dest);
134745	pPrior->pLimit = 0;
134746	if( rc ){
134747	goto multi_select_end;
134748	}
	@@ -134693,10 +134756,11 @@
134756	sqlite3VdbeAddOp3(v, OP_OffsetLimit,
134757	p->iLimit, p->iOffset+1, p->iOffset);
134758	}
134759	}
134760	ExplainQueryPlan((pParse, 1, "UNION ALL"));
134761	SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL right...\n"));
134762	rc = sqlite3Select(pParse, p, &dest);
134763	testcase( rc!=SQLITE_OK );
134764	pDelete = p->pPrior;
134765	p->pPrior = pPrior;
134766	p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
	@@ -134745,10 +134809,11 @@
134809
134810	/* Code the SELECT statements to our left
134811	*/
134812	assert( !pPrior->pOrderBy );
134813	sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
134814	SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION left...\n"));
134815	rc = sqlite3Select(pParse, pPrior, &uniondest);
134816	if( rc ){
134817	goto multi_select_end;
134818	}
134819
	@@ -134764,10 +134829,11 @@
134829	pLimit = p->pLimit;
134830	p->pLimit = 0;
134831	uniondest.eDest = op;
134832	ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
134833	sqlite3SelectOpName(p->op)));
134834	SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION right...\n"));
134835	rc = sqlite3Select(pParse, p, &uniondest);
134836	testcase( rc!=SQLITE_OK );
134837	assert( p->pOrderBy==0 );
134838	pDelete = p->pPrior;
134839	p->pPrior = pPrior;
	@@ -134824,10 +134890,11 @@
134890	assert( p->pEList );
134891
134892	/* Code the SELECTs to our left into temporary table "tab1".
134893	*/
134894	sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
134895	SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT left...\n"));
134896	rc = sqlite3Select(pParse, pPrior, &intersectdest);
134897	if( rc ){
134898	goto multi_select_end;
134899	}
134900
	@@ -134840,10 +134907,11 @@
134907	pLimit = p->pLimit;
134908	p->pLimit = 0;
134909	intersectdest.iSDParm = tab2;
134910	ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
134911	sqlite3SelectOpName(p->op)));
134912	SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT right...\n"));
134913	rc = sqlite3Select(pParse, p, &intersectdest);
134914	testcase( rc!=SQLITE_OK );
134915	pDelete = p->pPrior;
134916	p->pPrior = pPrior;
134917	if( p->nSelectRow>pPrior->nSelectRow ){
	@@ -136339,10 +136407,11 @@
136407	typedef struct WhereConst WhereConst;
136408	struct WhereConst {
136409	Parse pParse; / Parsing context */
136410	int nConst; /* Number for COLUMN=CONSTANT terms */
136411	int nChng; /* Number of times a constant is propagated */
136412	int bHasAffBlob; /* At least one column in apExpr[] as affinity BLOB */
136413	Expr *apExpr; / [i2] is COLUMN and [i2+1] is VALUE */
136414	};
136415
136416	/*
136417	** Add a new entry to the pConst object. Except, do not add duplicate
	@@ -136376,10 +136445,13 @@
136445	if( pE2->iTable==pColumn->iTable
136446	&& pE2->iColumn==pColumn->iColumn
136447	){
136448	return; /* Already present. Return without doing anything. */
136449	}
136450	}
136451	if( sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){
136452	pConst->bHasAffBlob = 1;
136453	}
136454
136455	pConst->nConst++;
136456	pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
136457	pConst->nConst2sizeof(Expr*));
	@@ -136418,30 +136490,38 @@
136490	constInsert(pConst,pLeft,pRight,pExpr);
136491	}
136492	}
136493
136494	/*
136495	** This is a helper function for Walker callback propagateConstantExprRewrite().
136496	**
136497	** Argument pExpr is a candidate expression to be replaced by a value. If
136498	** pExpr is equivalent to one of the columns named in pWalker->u.pConst,
136499	** then overwrite it with the corresponding value. Except, do not do so
136500	** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr
136501	** is SQLITE_AFF_BLOB.
136502	*/
136503	static int propagateConstantExprRewriteOne(
136504	WhereConst *pConst,
136505	Expr *pExpr,
136506	int bIgnoreAffBlob
136507	){
136508	int i;

136509	if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
136510	if( ExprHasProperty(pExpr, EP_FixedCol\|EP_FromJoin) ){
136511	testcase( ExprHasProperty(pExpr, EP_FixedCol) );
136512	testcase( ExprHasProperty(pExpr, EP_FromJoin) );
136513	return WRC_Continue;
136514	}

136515	for(i=0; i<pConst->nConst; i++){
136516	Expr pColumn = pConst->apExpr[i2];
136517	if( pColumn==pExpr ) continue;
136518	if( pColumn->iTable!=pExpr->iTable ) continue;
136519	if( pColumn->iColumn!=pExpr->iColumn ) continue;
136520	if( bIgnoreAffBlob && sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){
136521	break;
136522	}
136523	/* A match is found. Add the EP_FixedCol property */
136524	pConst->nChng++;
136525	ExprClearProperty(pExpr, EP_Leaf);
136526	ExprSetProperty(pExpr, EP_FixedCol);
136527	assert( pExpr->pLeft==0 );
	@@ -136448,10 +136528,45 @@
136528	pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
136529	break;
136530	}
136531	return WRC_Prune;
136532	}
136533
136534	/*
136535	** This is a Walker expression callback. pExpr is a node from the WHERE
136536	** clause of a SELECT statement. This function examines pExpr to see if
136537	** any substitutions based on the contents of pWalker->u.pConst should
136538	** be made to pExpr or its immediate children.
136539	**
136540	** A substitution is made if:
136541	**
136542	** + pExpr is a column with an affinity other than BLOB that matches
136543	** one of the columns in pWalker->u.pConst, or
136544	**
136545	** + pExpr is a binary comparison operator (=, <=, >=, <, >) that
136546	** uses an affinity other than TEXT and one of its immediate
136547	** children is a column that matches one of the columns in
136548	** pWalker->u.pConst.
136549	*/
136550	static int propagateConstantExprRewrite(Walker pWalker, Expr pExpr){
136551	WhereConst *pConst = pWalker->u.pConst;
136552	assert( TK_GT==TK_EQ+1 );
136553	assert( TK_LE==TK_EQ+2 );
136554	assert( TK_LT==TK_EQ+3 );
136555	assert( TK_GE==TK_EQ+4 );
136556	if( pConst->bHasAffBlob ){
136557	if( (pExpr->op>=TK_EQ && pExpr->op<=TK_GE)
136558	\|\| pExpr->op==TK_IS
136559	){
136560	propagateConstantExprRewriteOne(pConst, pExpr->pLeft, 0);
136561	if( sqlite3ExprAffinity(pExpr->pLeft)!=SQLITE_AFF_TEXT ){
136562	propagateConstantExprRewriteOne(pConst, pExpr->pRight, 0);
136563	}
136564	}
136565	}
136566	return propagateConstantExprRewriteOne(pConst, pExpr, pConst->bHasAffBlob);
136567	}
136568
136569	/*
136570	** The WHERE-clause constant propagation optimization.
136571	**
136572	** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
	@@ -136484,10 +136599,25 @@
136599	** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol
136600	** and the "123" value is hung off of the pLeft pointer. Code generator
136601	** routines know to generate the constant "123" instead of looking up the
136602	** column value. Also, to avoid collation problems, this optimization is
136603	** only attempted if the "a=123" term uses the default BINARY collation.
136604	**
136605	** 2021-05-25 forum post 6a06202608: Another troublesome case is...
136606	**
136607	** CREATE TABLE t1(x);
136608	** INSERT INTO t1 VALUES(10.0);
136609	** SELECT 1 FROM t1 WHERE x=10 AND x LIKE 10;
136610	**
136611	** The query should return no rows, because the t1.x value is '10.0' not '10'
136612	** and '10.0' is not LIKE '10'. But if we are not careful, the first WHERE
136613	** term "x=10" will cause the second WHERE term to become "10 LIKE 10",
136614	** resulting in a false positive. To avoid this, constant propagation for
136615	** columns with BLOB affinity is only allowed if the constant is used with
136616	** operators ==, <=, <, >=, >, or IS in a way that will cause the correct
136617	** type conversions to occur. See logic associated with the bHasAffBlob flag
136618	** for details.
136619	*/
136620	static int propagateConstants(
136621	Parse pParse, / The parsing context */
136622	Select p / The query in which to propagate constants */
136623	){
	@@ -136497,10 +136627,11 @@
136627	x.pParse = pParse;
136628	do{
136629	x.nConst = 0;
136630	x.nChng = 0;
136631	x.apExpr = 0;
136632	x.bHasAffBlob = 0;
136633	findConstInWhere(&x, p->pWhere);
136634	if( x.nConst ){
136635	memset(&w, 0, sizeof(w));
136636	w.pParse = pParse;
136637	w.xExprCallback = propagateConstantExprRewrite;
	@@ -136933,29 +137064,32 @@
137064	if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
137065	*ppContext = p;
137066	return &p->a[i];
137067	}
137068	}
137069	if( p->bView ) break;
137070	}
137071	return 0;
137072	}
137073
137074	/* The code generator maintains a stack of active WITH clauses
137075	** with the inner-most WITH clause being at the top of the stack.
137076	**
137077	** This routine pushes the WITH clause passed as the second argument
137078	** onto the top of the stack. If argument bFree is true, then this
137079	** WITH clause will never be popped from the stack but should instead
137080	** be freed along with the Parse object. In other cases, when
137081	** bFree==0, the With object will be freed along with the SELECT
137082	** statement with which it is associated.
137083	*/
137084	SQLITE_PRIVATE void sqlite3WithPush(Parse pParse, With pWith, u8 bFree){
137085	if( pWith ){
137086	if( pParse->nErr==0 ){
137087	assert( pParse->pWith!=pWith );
137088	pWith->pOuter = pParse->pWith;
137089	pParse->pWith = pWith;
137090	}
137091	if( bFree ){
137092	sqlite3ParserAddCleanup(pParse,
137093	(void()(sqlite3,void*))sqlite3WithDelete,
137094	pWith);
137095	testcase( pParse->earlyCleanup );
	@@ -136987,15 +137121,28 @@
137121
137122	assert( pFrom->pTab==0 );
137123	if( pParse->pWith==0 ){
137124	/* There are no WITH clauses in the stack. No match is possible */
137125	return 0;
137126	}
137127	if( pParse->nErr ){
137128	/* Prior errors might have left pParse->pWith in a goofy state, so
137129	** go no further. */
137130	return 0;
137131	}
137132	if( pFrom->zDatabase!=0 ){
137133	/* The FROM term contains a schema qualifier (ex: main.t1) and so
137134	** it cannot possibly be a CTE reference. */
137135	return 0;
137136	}
137137	if( pFrom->fg.notCte ){
137138	/* The FROM term is specifically excluded from matching a CTE.
137139	** (1) It is part of a trigger that used to have zDatabase but had
137140	** zDatabase removed by sqlite3FixTriggerStep().
137141	** (2) This is the first term in the FROM clause of an UPDATE.
137142	*/
137143	return 0;
137144	}
137145	pCte = searchWith(pParse->pWith, pFrom, &pWith);
137146	if( pCte ){
137147	sqlite3 *db = pParse->db;
137148	Table *pTab;
	@@ -137237,10 +137384,19 @@
137384	/* Renumber selId because it has been copied from a view */
137385	p->selId = ++pParse->nSelect;
137386	}
137387	pTabList = p->pSrc;
137388	pEList = p->pEList;
137389	if( pParse->pWith && (p->selFlags & SF_View) ){
137390	if( p->pWith==0 ){
137391	p->pWith = (With*)sqlite3DbMallocZero(db, sizeof(With));
137392	if( p->pWith==0 ){
137393	return WRC_Abort;
137394	}
137395	}
137396	p->pWith->bView = 1;
137397	}
137398	sqlite3WithPush(pParse, p->pWith, 0);
137399
137400	/* Make sure cursor numbers have been assigned to all entries in
137401	** the FROM clause of the SELECT statement.
137402	*/
	@@ -138124,11 +138280,11 @@
138280	}
138281	}
138282	}
138283
138284	if( pDest->eDest==SRT_Output ){
138285	sqlite3GenerateColumnNames(pParse, p);
138286	}
138287
138288	#ifndef SQLITE_OMIT_WINDOWFUNC
138289	if( sqlite3WindowRewrite(pParse, p) ){
138290	assert( db->mallocFailed \|\| pParse->nErr>0 );
	@@ -138318,23 +138474,12 @@
138474	/* Generate code for all sub-queries in the FROM clause
138475	*/
138476	pSub = pItem->pSelect;
138477	if( pSub==0 ) continue;
138478
138479	/* The code for a subquery should only be generated once. */
138480	assert( pItem->addrFillSub==0 );











138481
138482	/* Increment Parse.nHeight by the height of the largest expression
138483	** tree referred to by this, the parent select. The child select
138484	** may contain expression trees of at most
138485	** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
	@@ -138417,18 +138562,17 @@
138562	sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub);
138563	}
138564	sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
138565	pSub->nSelectRow = pPrior->pSelect->nSelectRow;
138566	}else{
138567	/* Materialize the view. If the view is not correlated, generate a
138568	** subroutine to do the materialization so that subsequent uses of
138569	** the same view can reuse the materialization. */
138570	int topAddr;
138571	int onceAddr = 0;
138572	int retAddr;
138573

138574	pItem->regReturn = ++pParse->nMem;
138575	topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
138576	pItem->addrFillSub = topAddr+1;
138577	if( pItem->fg.isCorrelated==0 ){
138578	/* If the subquery is not correlated and if we are not inside of
	@@ -140327,19 +140471,10 @@
140471	pItem->zEName = sqlite3DbStrDup(db, pList->a[i].zEName);
140472	pItem->eEName = pList->a[i].eEName;
140473	}
140474	}
140475	}









140476	return pNew;
140477	}
140478
140479	/*
140480	** Generate code for the RETURNING trigger. Unlike other triggers
	@@ -140351,17 +140486,31 @@
140486	Trigger pTrigger, / The trigger step that defines the RETURNING */
140487	Table pTab, / The table to code triggers from */
140488	int regIn /* The first in an array of registers */
140489	){
140490	Vdbe *v = pParse->pVdbe;
140491	sqlite3 *db = pParse->db;
140492	ExprList *pNew;
140493	Returning *pReturning;
140494	Select sSelect;
140495	SrcList sFrom;
140496
140497	assert( v!=0 );
140498	assert( pParse->bReturning );
140499	pReturning = pParse->u1.pReturning;
140500	assert( pTrigger == &(pReturning->retTrig) );
140501	memset(&sSelect, 0, sizeof(sSelect));
140502	memset(&sFrom, 0, sizeof(sFrom));
140503	sSelect.pEList = sqlite3ExprListDup(db, pReturning->pReturnEL, 0);
140504	sSelect.pSrc = &sFrom;
140505	sFrom.nSrc = 1;
140506	sFrom.a[0].pTab = pTab;
140507	sqlite3SelectPrep(pParse, &sSelect, 0);
140508	if( db->mallocFailed==0 && pParse->nErr==0 ){
140509	sqlite3GenerateColumnNames(pParse, &sSelect);
140510	}
140511	sqlite3ExprListDelete(db, sSelect.pEList);
140512	pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
140513	if( pNew ){
140514	NameContext sNC;
140515	memset(&sNC, 0, sizeof(sNC));
140516	if( pReturning->nRetCol==0 ){
	@@ -140378,17 +140527,18 @@
140527	int nCol = pNew->nExpr;
140528	int reg = pParse->nMem+1;
140529	pParse->nMem += nCol+2;
140530	pReturning->iRetReg = reg;
140531	for(i=0; i<nCol; i++){
140532	Expr *pCol = pNew->a[i].pExpr;
140533	sqlite3ExprCodeFactorable(pParse, pCol, reg+i);
140534	}
140535	sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, i, reg+i);
140536	sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1);
140537	sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1);
140538	}
140539	sqlite3ExprListDelete(db, pNew);
140540	pParse->eTriggerOp = 0;
140541	pParse->pTriggerTab = 0;
140542	}
140543	}
140544
	@@ -141067,10 +141217,11 @@
141217	pSrc = sqlite3SrcListDup(db, pTabList, 0);
141218	pWhere2 = sqlite3ExprDup(db, pWhere, 0);
141219
141220	assert( pTabList->nSrc>1 );
141221	if( pSrc ){
141222	pSrc->a[0].fg.notCte = 1;
141223	pSrc->a[0].iCursor = -1;
141224	pSrc->a[0].pTab->nTabRef--;
141225	pSrc->a[0].pTab = 0;
141226	}
141227	if( pPk ){
	@@ -145593,11 +145744,11 @@
145744	if( r1!=regBase+j ){
145745	if( nReg==1 ){
145746	sqlite3ReleaseTempReg(pParse, regBase);
145747	regBase = r1;
145748	}else{
145749	sqlite3VdbeAddOp2(v, OP_Copy, r1, regBase+j);
145750	}
145751	}
145752	if( pTerm->eOperator & WO_IN ){
145753	if( pTerm->pExpr->flags & EP_xIsSelect ){
145754	/* No affinity ever needs to be (or should be) applied to a value
	@@ -145610,11 +145761,11 @@
145761	Expr *pRight = pTerm->pExpr->pRight;
145762	if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){
145763	sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
145764	VdbeCoverage(v);
145765	}
145766	if( pParse->db->mallocFailed==0 && pParse->nErr==0 ){
145767	if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){
145768	zAff[j] = SQLITE_AFF_BLOB;
145769	}
145770	if( sqlite3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){
145771	zAff[j] = SQLITE_AFF_BLOB;
	@@ -145959,11 +146110,11 @@
146110	for(i=0; i<nReg; i++){
146111	sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
146112	}
146113	}
146114	}else{
146115	assert( nReg==1 \|\| pParse->nErr );
146116	sqlite3ExprCode(pParse, p, iReg);
146117	}
146118	}
146119
146120	/* An instance of the IdxExprTrans object carries information about a
	@@ -147007,11 +147158,11 @@
147158	}
147159	if( pAndExpr ){
147160	/* The extra 0x10000 bit on the opcode is masked off and does not
147161	** become part of the new Expr.op. However, it does make the
147162	** op==TK_AND comparison inside of sqlite3PExpr() false, and this
147163	** prevents sqlite3PExpr() from applying the AND short-circuit
147164	** optimization, which we do not want here. */
147165	pAndExpr = sqlite3PExpr(pParse, TK_AND\|0x10000, 0, pAndExpr);
147166	}
147167	}
147168
	@@ -147023,14 +147174,20 @@
147174	for(ii=0; ii<pOrWc->nTerm; ii++){
147175	WhereTerm *pOrTerm = &pOrWc->a[ii];
147176	if( pOrTerm->leftCursor==iCur \|\| (pOrTerm->eOperator & WO_AND)!=0 ){
147177	WhereInfo pSubWInfo; / Info for single OR-term scan */
147178	Expr pOrExpr = pOrTerm->pExpr; / Current OR clause term */
147179	Expr pDelete; / Local copy of OR clause term */
147180	int jmp1 = 0; /* Address of jump operation */
147181	testcase( (pTabItem[0].fg.jointype & JT_LEFT)!=0
147182	&& !ExprHasProperty(pOrExpr, EP_FromJoin)
147183	); /* See TH3 vtab25.400 and ticket 614b25314c766238 */
147184	pDelete = pOrExpr = sqlite3ExprDup(db, pOrExpr, 0);
147185	if( db->mallocFailed ){
147186	sqlite3ExprDelete(db, pDelete);
147187	continue;
147188	}
147189	if( pAndExpr ){
147190	pAndExpr->pLeft = pOrExpr;
147191	pOrExpr = pAndExpr;
147192	}
147193	/* Loop through table entries that match term pOrTerm. */
	@@ -147141,10 +147298,11 @@
147298
147299	/* Finish the loop through table entries that match term pOrTerm. */
147300	sqlite3WhereEnd(pSubWInfo);
147301	ExplainQueryPlanPop(pParse);
147302	}
147303	sqlite3ExprDelete(db, pDelete);
147304	}
147305	}
147306	ExplainQueryPlanPop(pParse);
147307	pLevel->u.pCovidx = pCov;
147308	if( pCov ) pLevel->iIdxCur = iCovCur;
	@@ -151888,10 +152046,11 @@
152046	Expr *pExpr;
152047	pExpr = pTerm->pExpr;
152048	if( (!ExprHasProperty(pExpr, EP_FromJoin) \|\| pExpr->iRightJoinTable==iTab)
152049	&& (isLeft==0 \|\| ExprHasProperty(pExpr, EP_FromJoin))
152050	&& sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
152051	&& (pTerm->wtFlags & TERM_VNULL)==0
152052	){
152053	return 1;
152054	}
152055	}
152056	return 0;
	@@ -155605,11 +155764,11 @@
155764	** are invoked in the correct order as described under "SELECT REWRITING"
155765	** at the top of this file.
155766	*/
155767	SQLITE_PRIVATE int sqlite3WindowRewrite(Parse pParse, Select p){
155768	int rc = SQLITE_OK;
155769	if( p->pWin && p->pPrior==0 && ALWAYS((p->selFlags & SF_WinRewrite)==0) ){
155770	Vdbe *v = sqlite3GetVdbe(pParse);
155771	sqlite3 *db = pParse->db;
155772	Select pSub = 0; / The subquery */
155773	SrcList *pSrc = p->pSrc;
155774	Expr *pWhere = p->pWhere;
	@@ -155631,10 +155790,11 @@
155790	}
155791	sqlite3AggInfoPersistWalkerInit(&w, pParse);
155792	sqlite3WalkSelect(&w, p);
155793	if( (p->selFlags & SF_Aggregate)==0 ){
155794	w.xExprCallback = disallowAggregatesInOrderByCb;
155795	w.xSelectCallback = 0;
155796	sqlite3WalkExprList(&w, p->pOrderBy);
155797	}
155798
155799	p->pSrc = 0;
155800	p->pWhere = 0;
	@@ -158141,12 +158301,13 @@
158301	#define TK_VECTOR 176
158302	#define TK_SELECT_COLUMN 177
158303	#define TK_IF_NULL_ROW 178
158304	#define TK_ASTERISK 179
158305	#define TK_SPAN 180
158306	#define TK_ERROR 181
158307	#define TK_SPACE 182
158308	#define TK_ILLEGAL 183
158309	#endif
158310	/************** End token definitions *************************************/
158311
158312	/* The next sections is a series of control #defines.
158313	** various aspects of the generated parser.
	@@ -158202,33 +158363,33 @@
158363	#ifndef INTERFACE
158364	# define INTERFACE 1
158365	#endif
158366	/*********** Begin control #defines ***************************************/
158367	#define YYCODETYPE unsigned short int
158368	#define YYNOCODE 317
158369	#define YYACTIONTYPE unsigned short int
158370	#define YYWILDCARD 101
158371	#define sqlite3ParserTOKENTYPE Token
158372	typedef union {
158373	int yyinit;
158374	sqlite3ParserTOKENTYPE yy0;
158375	Window* yy49;
158376	ExprList* yy70;
158377	Select* yy81;
158378	With* yy103;
158379	struct FrameBound yy117;
158380	struct {int value; int mask;} yy139;
158381	SrcList* yy153;
158382	TriggerStep* yy157;
158383	Upsert* yy190;
158384	struct TrigEvent yy262;
158385	Cte* yy329;
158386	int yy376;
158387	Expr* yy404;
158388	IdList* yy436;
158389	const char* yy504;
158390	u8 yy552;
158391	} YYMINORTYPE;
158392	#ifndef YYSTACKDEPTH
158393	#define YYSTACKDEPTH 100
158394	#endif
158395	#define sqlite3ParserARG_SDECL
	@@ -158243,11 +158404,11 @@
158404	#define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
158405	#define YYFALLBACK 1
158406	#define YYNSTATE 570
158407	#define YYNRULE 398
158408	#define YYNRULE_WITH_ACTION 337
158409	#define YYNTOKEN 184
158410	#define YY_MAX_SHIFT 569
158411	#define YY_MIN_SHIFTREDUCE 825
158412	#define YY_MAX_SHIFTREDUCE 1222
158413	#define YY_ERROR_ACTION 1223
158414	#define YY_ACCEPT_ACTION 1224
	@@ -158318,545 +158479,546 @@
158479	** yy_reduce_ofst[] For each state, the offset into yy_action for
158480	** shifting non-terminals after a reduce.
158481	** yy_default[] Default action for each state.
158482	**
158483	********* Begin parsing tables ********************************************/
158484	#define YY_ACTTAB_COUNT (2023)
158485	static const YYACTIONTYPE yy_action[] = {
158486	/* 0 */ 563, 1295, 563, 1274, 168, 1257, 115, 112, 218, 373,
158487	/* 10 */ 563, 1295, 374, 563, 488, 563, 115, 112, 218, 406,
158488	/* 20 */ 1300, 1300, 41, 41, 41, 41, 514, 1504, 520, 1298,
158489	/* 30 */ 1298, 959, 41, 41, 1260, 71, 71, 51, 51, 960,
158490	/* 40 */ 557, 557, 557, 122, 123, 113, 1200, 1200, 1035, 1038,
158491	/* 50 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 414, 406,
158492	/* 60 */ 273, 273, 273, 273, 115, 112, 218, 115, 112, 218,
158493	/* 70 */ 197, 268, 545, 560, 515, 560, 211, 563, 385, 248,
158494	/* 80 */ 215, 521, 399, 122, 123, 113, 1200, 1200, 1035, 1038,
158495	/* 90 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 540, 13,
158496	/* 100 */ 13, 1259, 119, 119, 119, 119, 118, 118, 117, 117,
158497	/* 110 */ 117, 116, 441, 1176, 419, 197, 446, 320, 512, 1539,
158498	/* 120 */ 1545, 372, 1547, 6, 371, 1176, 1148, 394, 1148, 406,
158499	/* 130 */ 1545, 534, 115, 112, 218, 1415, 99, 30, 121, 121,
158500	/* 140 */ 121, 121, 119, 119, 119, 119, 118, 118, 117, 117,
158501	/* 150 */ 117, 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038,
158502	/* 160 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 31, 1176,
158503	/* 170 */ 1177, 1178, 241, 357, 1558, 501, 498, 497, 317, 124,
158504	/* 180 */ 319, 1176, 1177, 1178, 1176, 496, 119, 119, 119, 119,
158505	/* 190 */ 118, 118, 117, 117, 117, 116, 441, 139, 96, 406,
158506	/* 200 */ 121, 121, 121, 121, 114, 117, 117, 117, 116, 441,
158507	/* 210 */ 541, 1532, 119, 119, 119, 119, 118, 118, 117, 117,
158508	/* 220 */ 117, 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038,
158509	/* 230 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 406, 441,
158510	/* 240 */ 1176, 1177, 1178, 81, 439, 439, 439, 80, 119, 119,
158511	/* 250 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 488,
158512	/* 260 */ 1176, 318, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158513	/* 270 */ 1028, 120, 120, 121, 121, 121, 121, 493, 1025, 1025,
158514	/* 280 */ 1036, 1039, 119, 119, 119, 119, 118, 118, 117, 117,
158515	/* 290 */ 117, 116, 441, 1584, 995, 1224, 1, 1, 569, 2,
158516	/* 300 */ 1228, 1267, 137, 1503, 245, 305, 473, 140, 406, 860,
158517	/* 310 */ 561, 1176, 914, 914, 1308, 359, 1176, 1177, 1178, 462,
158518	/* 320 */ 330, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158519	/* 330 */ 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158520	/* 340 */ 1028, 120, 120, 121, 121, 121, 121, 328, 273, 273,
158521	/* 350 */ 1015, 83, 1029, 425, 1564, 569, 2, 1228, 304, 554,
158522	/* 360 */ 925, 560, 305, 944, 140, 860, 1006, 1176, 1177, 1178,
158523	/* 370 */ 1005, 1308, 411, 213, 511, 229, 119, 119, 119, 119,
158524	/* 380 */ 118, 118, 117, 117, 117, 116, 441, 519, 347, 116,
158525	/* 390 */ 441, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158526	/* 400 */ 116, 441, 1005, 1005, 1007, 273, 273, 445, 563, 16,
158527	/* 410 */ 16, 1590, 563, 1540, 563, 406, 1176, 6, 560, 344,
158528	/* 420 */ 182, 118, 118, 117, 117, 117, 116, 441, 416, 142,
158529	/* 430 */ 71, 71, 229, 563, 71, 71, 55, 55, 203, 122,
158530	/* 440 */ 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120,
158531	/* 450 */ 121, 121, 121, 121, 217, 13, 13, 1176, 406, 568,
158532	/* 460 */ 1400, 1228, 502, 137, 445, 168, 305, 545, 140, 1180,
158533	/* 470 */ 424, 545, 1176, 1177, 1178, 1308, 544, 438, 437, 944,
158534	/* 480 */ 513, 452, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158535	/* 490 */ 1028, 120, 120, 121, 121, 121, 121, 315, 119, 119,
158536	/* 500 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 273,
158537	/* 510 */ 273, 1143, 416, 1176, 1177, 1178, 543, 563, 1143, 304,
158538	/* 520 */ 554, 1561, 560, 1207, 1143, 1207, 1180, 1143, 406, 530,
158539	/* 530 */ 421, 1143, 864, 183, 1143, 143, 229, 562, 32, 71,
158540	/* 540 */ 71, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158541	/* 550 */ 116, 441, 122, 123, 113, 1200, 1200, 1035, 1038, 1028,
158542	/* 560 */ 1028, 120, 120, 121, 121, 121, 121, 406, 445, 241,
158543	/* 570 */ 1176, 857, 501, 498, 497, 1176, 526, 189, 245, 538,
158544	/* 580 */ 1539, 282, 496, 370, 6, 563, 529, 477, 5, 279,
158545	/* 590 */ 1015, 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
158546	/* 600 */ 120, 120, 121, 121, 121, 121, 1006, 13, 13, 1414,
158547	/* 610 */ 1005, 119, 119, 119, 119, 118, 118, 117, 117, 117,
158548	/* 620 */ 116, 441, 426, 273, 273, 1176, 1176, 1177, 1178, 1619,
158549	/* 630 */ 392, 1176, 1177, 1178, 1176, 342, 560, 406, 525, 361,
158550	/* 640 */ 430, 1161, 1005, 1005, 1007, 348, 411, 357, 1558, 488,
158551	/* 650 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116,
158552	/* 660 */ 441, 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
158553	/* 670 */ 120, 120, 121, 121, 121, 121, 406, 830, 831, 832,
158554	/* 680 */ 1016, 1176, 1177, 1178, 396, 285, 148, 1312, 304, 554,
158555	/* 690 */ 1176, 1177, 1178, 1467, 216, 3, 337, 137, 340, 560,
158556	/* 700 */ 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120,
158557	/* 710 */ 120, 121, 121, 121, 121, 563, 504, 946, 273, 273,
158558	/* 720 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116,
158559	/* 730 */ 441, 560, 1176, 427, 563, 451, 98, 13, 13, 259,
158560	/* 740 */ 276, 356, 507, 351, 506, 246, 406, 361, 469, 1530,
158561	/* 750 */ 1000, 347, 293, 304, 554, 1589, 71, 71, 889, 119,
158562	/* 760 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 441,
158563	/* 770 */ 122, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120,
158564	/* 780 */ 120, 121, 121, 121, 121, 406, 1143, 1078, 1176, 1177,
158565	/* 790 */ 1178, 416, 1080, 300, 150, 995, 1080, 361, 361, 1143,
158566	/* 800 */ 361, 378, 1143, 477, 563, 244, 243, 242, 1278, 122,
158567	/* 810 */ 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120,
158568	/* 820 */ 121, 121, 121, 121, 563, 880, 13, 13, 483, 119,
158569	/* 830 */ 119, 119, 119, 118, 118, 117, 117, 117, 116, 441,
158570	/* 840 */ 1176, 191, 540, 563, 147, 149, 13, 13, 328, 457,
158571	/* 850 */ 316, 1083, 1083, 485, 1537, 406, 505, 1530, 6, 1514,
158572	/* 860 */ 284, 192, 1277, 145, 881, 71, 71, 488, 119, 119,
158573	/* 870 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 122,
158574	/* 880 */ 123, 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120,
158575	/* 890 */ 121, 121, 121, 121, 563, 471, 1176, 1177, 1178, 406,
158576	/* 900 */ 852, 327, 301, 462, 330, 1516, 270, 1530, 1530, 944,
158577	/* 910 */ 1531, 1307, 313, 9, 842, 251, 71, 71, 477, 428,
158578	/* 920 */ 146, 488, 38, 945, 101, 113, 1200, 1200, 1035, 1038,
158579	/* 930 */ 1028, 1028, 120, 120, 121, 121, 121, 121, 119, 119,
158580	/* 940 */ 119, 119, 118, 118, 117, 117, 117, 116, 441, 563,
158581	/* 950 */ 1197, 1099, 563, 436, 563, 1533, 563, 852, 1122, 1617,
158582	/* 960 */ 454, 290, 1617, 546, 251, 1303, 1100, 267, 267, 281,
158583	/* 970 */ 404, 70, 70, 460, 71, 71, 71, 71, 13, 13,
158584	/* 980 */ 560, 1101, 119, 119, 119, 119, 118, 118, 117, 117,
158585	/* 990 */ 117, 116, 441, 542, 104, 273, 273, 273, 273, 1197,
158586	/* 1000 */ 217, 1468, 900, 471, 450, 563, 1473, 1197, 560, 447,
158587	/* 1010 */ 560, 545, 901, 440, 406, 1058, 292, 274, 274, 198,
158588	/* 1020 */ 547, 450, 449, 1473, 1475, 944, 455, 56, 56, 410,
158589	/* 1030 */ 560, 1122, 1618, 379, 406, 1618, 404, 1120, 122, 123,
158590	/* 1040 */ 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120, 121,
158591	/* 1050 */ 121, 121, 121, 1460, 406, 12, 1197, 1512, 122, 123,
158592	/* 1060 */ 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120, 121,
158593	/* 1070 */ 121, 121, 121, 308, 471, 126, 359, 286, 122, 111,
158594	/* 1080 */ 113, 1200, 1200, 1035, 1038, 1028, 1028, 120, 120, 121,
158595	/* 1090 */ 121, 121, 121, 309, 450, 471, 1473, 119, 119, 119,
158596	/* 1100 */ 119, 118, 118, 117, 117, 117, 116, 441, 1176, 563,
158597	/* 1110 */ 1120, 482, 563, 312, 433, 479, 197, 119, 119, 119,
158598	/* 1120 */ 119, 118, 118, 117, 117, 117, 116, 441, 405, 12,
158599	/* 1130 */ 536, 15, 15, 478, 43, 43, 509, 119, 119, 119,
158600	/* 1140 */ 119, 118, 118, 117, 117, 117, 116, 441, 289, 535,
158601	/* 1150 */ 294, 563, 294, 391, 1220, 438, 437, 406, 1154, 403,
158602	/* 1160 */ 402, 1400, 920, 1204, 1176, 1177, 1178, 919, 1206, 291,
158603	/* 1170 */ 1306, 1249, 412, 57, 57, 488, 1205, 563, 556, 412,
158604	/* 1180 */ 1176, 1344, 123, 113, 1200, 1200, 1035, 1038, 1028, 1028,
158605	/* 1190 */ 120, 120, 121, 121, 121, 121, 1400, 1143, 563, 44,
158606	/* 1200 */ 44, 1207, 194, 1207, 273, 273, 1400, 461, 537, 1154,
158607	/* 1210 */ 1143, 108, 555, 1143, 4, 391, 1121, 560, 1538, 335,
158608	/* 1220 */ 58, 58, 6, 1246, 1099, 380, 1400, 376, 558, 1536,
158609	/* 1230 */ 563, 422, 1221, 6, 304, 554, 1176, 1177, 1178, 1100,
158610	/* 1240 */ 119, 119, 119, 119, 118, 118, 117, 117, 117, 116,
158611	/* 1250 */ 441, 442, 59, 59, 1101, 516, 1535, 273, 273, 563,
158612	/* 1260 */ 6, 563, 110, 552, 563, 528, 423, 413, 169, 548,
158613	/* 1270 */ 560, 108, 555, 137, 4, 551, 484, 272, 215, 222,
158614	/* 1280 */ 211, 60, 60, 61, 61, 98, 62, 62, 558, 273,
158615	/* 1290 */ 273, 563, 1015, 467, 1221, 563, 434, 563, 106, 106,
158616	/* 1300 */ 8, 920, 560, 273, 273, 107, 919, 442, 565, 564,
158617	/* 1310 */ 563, 442, 1005, 45, 45, 464, 560, 46, 46, 47,
158618	/* 1320 */ 47, 84, 202, 552, 1215, 404, 468, 563, 205, 304,
158619	/* 1330 */ 554, 563, 49, 49, 563, 522, 404, 532, 563, 867,
158620	/* 1340 */ 563, 105, 531, 103, 1005, 1005, 1007, 1008, 27, 50,
158621	/* 1350 */ 50, 563, 1015, 63, 63, 475, 64, 64, 106, 106,
158622	/* 1360 */ 65, 65, 14, 14, 17, 107, 563, 442, 565, 564,
158623	/* 1370 */ 563, 303, 1005, 66, 66, 563, 226, 563, 959, 563,
158624	/* 1380 */ 543, 404, 1196, 1343, 871, 278, 960, 456, 128, 128,
158625	/* 1390 */ 563, 1065, 67, 67, 563, 206, 867, 52, 52, 68,
158626	/* 1400 */ 68, 69, 69, 417, 1005, 1005, 1007, 1008, 27, 1563,
158627	/* 1410 */ 1165, 444, 53, 53, 277, 1519, 156, 156, 307, 389,
158628	/* 1420 */ 389, 388, 262, 386, 1165, 444, 839, 321, 277, 108,
158629	/* 1430 */ 555, 523, 4, 389, 389, 388, 262, 386, 563, 223,
158630	/* 1440 */ 839, 311, 326, 1492, 1117, 98, 558, 393, 1065, 310,
158631	/* 1450 */ 563, 476, 563, 223, 563, 311, 879, 878, 1009, 277,
158632	/* 1460 */ 157, 157, 463, 310, 389, 389, 388, 262, 386, 442,
158633	/* 1470 */ 518, 839, 76, 76, 54, 54, 72, 72, 355, 225,
158634	/* 1480 */ 563, 552, 275, 563, 223, 325, 311, 161, 354, 465,
158635	/* 1490 */ 135, 563, 228, 225, 310, 532, 563, 206, 886, 887,
158636	/* 1500 */ 533, 161, 129, 129, 135, 73, 73, 224, 962, 963,
158637	/* 1510 */ 1015, 563, 287, 130, 130, 1009, 106, 106, 131, 131,
158638	/* 1520 */ 563, 224, 563, 107, 225, 442, 565, 564, 997, 1276,
158639	/* 1530 */ 1005, 250, 161, 127, 127, 135, 108, 555, 1077, 4,
158640	/* 1540 */ 1077, 407, 155, 155, 154, 154, 304, 554, 1126, 563,
158641	/* 1550 */ 1331, 563, 224, 558, 470, 407, 563, 250, 563, 1491,
158642	/* 1560 */ 304, 554, 1005, 1005, 1007, 1008, 27, 563, 480, 332,
158643	/* 1570 */ 448, 136, 136, 134, 134, 1340, 442, 336, 132, 132,
158644	/* 1580 */ 133, 133, 563, 1076, 448, 1076, 407, 563, 552, 75,
158645	/* 1590 */ 75, 304, 554, 339, 341, 343, 108, 555, 563, 4,
158646	/* 1600 */ 1577, 299, 532, 563, 77, 77, 1291, 531, 472, 74,
158647	/* 1610 */ 74, 250, 1275, 558, 350, 448, 331, 1015, 360, 98,
158648	/* 1620 */ 42, 42, 1352, 106, 106, 48, 48, 1399, 494, 1327,
158649	/* 1630 */ 107, 247, 442, 565, 564, 345, 442, 1005, 98, 1061,
158650	/* 1640 */ 953, 917, 247, 250, 110, 1552, 550, 850, 552, 918,
158651	/* 1650 */ 144, 1338, 110, 549, 1405, 1256, 1248, 1237, 1236, 1238,
158652	/* 1660 */ 1571, 1324, 208, 390, 489, 265, 363, 200, 365, 1005,
158653	/* 1670 */ 1005, 1007, 1008, 27, 11, 280, 221, 1015, 323, 474,
158654	/* 1680 */ 1274, 367, 212, 106, 106, 924, 1386, 324, 288, 1381,
158655	/* 1690 */ 107, 453, 442, 565, 564, 283, 329, 1005, 1391, 499,
158656	/* 1700 */ 353, 1374, 1464, 108, 555, 1463, 4, 1574, 1390, 397,
158657	/* 1710 */ 1215, 171, 254, 369, 383, 207, 195, 196, 1511, 553,
158658	/* 1720 */ 558, 1509, 415, 1212, 100, 555, 83, 4, 204, 1005,
158659	/* 1730 */ 1005, 1007, 1008, 27, 180, 166, 173, 219, 79, 82,
158660	/* 1740 */ 458, 558, 175, 442, 35, 1387, 176, 459, 177, 178,
158661	/* 1750 */ 492, 231, 96, 1469, 395, 552, 1393, 1392, 36, 466,
158662	/* 1760 */ 1395, 184, 398, 481, 442, 1458, 235, 89, 1480, 487,
158663	/* 1770 */ 266, 334, 237, 188, 490, 400, 552, 338, 238, 508,
158664	/* 1780 */ 1239, 239, 1294, 1293, 1015, 1292, 1285, 429, 91, 871,
158665	/* 1790 */ 106, 106, 1588, 213, 401, 1587, 431, 107, 1264, 442,
158666	/* 1800 */ 565, 564, 1263, 352, 1005, 1015, 1262, 1586, 1557, 517,
158667	/* 1810 */ 432, 106, 106, 1284, 297, 298, 358, 524, 107, 1335,
158668	/* 1820 */ 442, 565, 564, 95, 1336, 1005, 252, 253, 435, 125,
158669	/* 1830 */ 543, 1543, 10, 1444, 377, 1542, 1005, 1005, 1007, 1008,
158670	/* 1840 */ 27, 97, 527, 375, 362, 102, 260, 364, 381, 1317,
158671	/* 1850 */ 382, 1334, 366, 1245, 1333, 1316, 368, 1005, 1005, 1007,
158672	/* 1860 */ 1008, 27, 1359, 1358, 34, 199, 1171, 566, 261, 263,
158673	/* 1870 */ 264, 567, 1234, 158, 1229, 141, 295, 159, 1496, 302,
158674	/* 1880 */ 1497, 1495, 1494, 160, 826, 209, 443, 201, 306, 210,
158675	/* 1890 */ 78, 220, 1075, 138, 1073, 314, 162, 172, 1196, 227,
158676	/* 1900 */ 174, 903, 322, 230, 1089, 179, 163, 164, 418, 408,
158677	/* 1910 */ 409, 170, 181, 85, 86, 420, 87, 165, 1092, 88,
158678	/* 1920 */ 233, 232, 1088, 151, 18, 234, 1081, 250, 333, 1209,
158679	/* 1930 */ 185, 486, 236, 186, 37, 841, 491, 354, 240, 346,
158680	/* 1940 */ 495, 187, 90, 869, 19, 20, 500, 503, 349, 92,
158681	/* 1950 */ 167, 152, 296, 882, 93, 510, 94, 1159, 153, 1041,
158682	/* 1960 */ 1128, 39, 214, 269, 1127, 271, 249, 952, 190, 947,
158683	/* 1970 */ 110, 1149, 21, 7, 1153, 22, 1145, 23, 1147, 24,
158684	/* 1980 */ 1133, 25, 1152, 33, 539, 193, 26, 1056, 98, 1042,
158685	/* 1990 */ 1040, 1044, 1098, 1045, 1097, 256, 255, 28, 40, 257,
158686	/* 2000 */ 1010, 851, 109, 29, 913, 559, 384, 387, 258, 1167,
158687	/* 2010 */ 1166, 1225, 1225, 1225, 1579, 1225, 1225, 1225, 1225, 1225,
158688	/* 2020 */ 1225, 1225, 1578,
158689	};
158690	static const YYCODETYPE yy_lookahead[] = {
158691	/* 0 */ 192, 221, 192, 223, 192, 214, 272, 273, 274, 217,
158692	/* 10 */ 192, 231, 217, 192, 192, 192, 272, 273, 274, 19,
158693	/* 20 */ 233, 234, 214, 215, 214, 215, 203, 293, 203, 233,
158694	/* 30 */ 234, 31, 214, 215, 214, 214, 215, 214, 215, 39,
158695	/* 40 */ 208, 209, 210, 43, 44, 45, 46, 47, 48, 49,
158696	/* 50 */ 50, 51, 52, 53, 54, 55, 56, 57, 236, 19,
158697	/* 60 */ 237, 238, 237, 238, 272, 273, 274, 272, 273, 274,
158698	/* 70 */ 192, 211, 251, 250, 251, 250, 26, 192, 200, 254,
158699	/* 80 */ 255, 260, 204, 43, 44, 45, 46, 47, 48, 49,
158700	/* 90 */ 50, 51, 52, 53, 54, 55, 56, 57, 192, 214,
158701	/* 100 */ 215, 214, 102, 103, 104, 105, 106, 107, 108, 109,
158702	/* 110 */ 110, 111, 112, 59, 229, 192, 294, 16, 306, 307,
158703	/* 120 */ 312, 313, 312, 311, 314, 59, 86, 204, 88, 19,
158704	/* 130 */ 312, 313, 272, 273, 274, 271, 26, 22, 54, 55,
158705	/* 140 */ 56, 57, 102, 103, 104, 105, 106, 107, 108, 109,
158706	/* 150 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49,
158707	/* 160 */ 50, 51, 52, 53, 54, 55, 56, 57, 53, 115,
158708	/* 170 */ 116, 117, 118, 309, 310, 121, 122, 123, 77, 69,
158709	/* 180 */ 79, 115, 116, 117, 59, 131, 102, 103, 104, 105,
158710	/* 190 */ 106, 107, 108, 109, 110, 111, 112, 72, 148, 19,
158711	/* 200 */ 54, 55, 56, 57, 58, 108, 109, 110, 111, 112,
158712	/* 210 */ 304, 305, 102, 103, 104, 105, 106, 107, 108, 109,
158713	/* 220 */ 110, 111, 112, 43, 44, 45, 46, 47, 48, 49,
158714	/* 230 */ 50, 51, 52, 53, 54, 55, 56, 57, 19, 112,
158715	/* 240 */ 115, 116, 117, 24, 208, 209, 210, 67, 102, 103,
158716	/* 250 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 192,
158717	/* 260 */ 59, 160, 43, 44, 45, 46, 47, 48, 49, 50,
158718	/* 270 */ 51, 52, 53, 54, 55, 56, 57, 19, 46, 47,
158719	/* 280 */ 48, 49, 102, 103, 104, 105, 106, 107, 108, 109,
158720	/* 290 */ 110, 111, 112, 213, 73, 184, 185, 186, 187, 188,
158721	/* 300 */ 189, 221, 81, 236, 46, 194, 192, 196, 19, 59,
158722	/* 310 */ 133, 59, 135, 136, 203, 192, 115, 116, 117, 127,
158723	/* 320 */ 128, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158724	/* 330 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50,
158725	/* 340 */ 51, 52, 53, 54, 55, 56, 57, 126, 237, 238,
158726	/* 350 */ 100, 150, 120, 230, 186, 187, 188, 189, 137, 138,
158727	/* 360 */ 108, 250, 194, 26, 196, 115, 116, 115, 116, 117,
158728	/* 370 */ 120, 203, 114, 164, 165, 264, 102, 103, 104, 105,
158729	/* 380 */ 106, 107, 108, 109, 110, 111, 112, 192, 130, 111,
158730	/* 390 */ 112, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158731	/* 400 */ 111, 112, 152, 153, 154, 237, 238, 296, 192, 214,
158732	/* 410 */ 215, 228, 192, 307, 192, 19, 59, 311, 250, 23,
158733	/* 420 */ 22, 106, 107, 108, 109, 110, 111, 112, 192, 72,
158734	/* 430 */ 214, 215, 264, 192, 214, 215, 214, 215, 149, 43,
158735	/* 440 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
158736	/* 450 */ 54, 55, 56, 57, 117, 214, 215, 59, 19, 187,
158737	/* 460 */ 192, 189, 23, 81, 296, 192, 194, 251, 196, 59,
158738	/* 470 */ 229, 251, 115, 116, 117, 203, 260, 106, 107, 142,
158739	/* 480 */ 260, 267, 43, 44, 45, 46, 47, 48, 49, 50,
158740	/* 490 */ 51, 52, 53, 54, 55, 56, 57, 261, 102, 103,
158741	/* 500 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 237,
158742	/* 510 */ 238, 76, 192, 115, 116, 117, 144, 192, 76, 137,
158743	/* 520 */ 138, 192, 250, 152, 89, 154, 116, 92, 19, 87,
158744	/* 530 */ 262, 89, 23, 22, 92, 163, 264, 192, 22, 214,
158745	/* 540 */ 215, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158746	/* 550 */ 111, 112, 43, 44, 45, 46, 47, 48, 49, 50,
158747	/* 560 */ 51, 52, 53, 54, 55, 56, 57, 19, 296, 118,
158748	/* 570 */ 59, 23, 121, 122, 123, 59, 251, 26, 46, 306,
158749	/* 580 */ 307, 261, 131, 192, 311, 192, 144, 192, 22, 203,
158750	/* 590 */ 100, 43, 44, 45, 46, 47, 48, 49, 50, 51,
158751	/* 600 */ 52, 53, 54, 55, 56, 57, 116, 214, 215, 271,
158752	/* 610 */ 120, 102, 103, 104, 105, 106, 107, 108, 109, 110,
158753	/* 620 */ 111, 112, 229, 237, 238, 59, 115, 116, 117, 299,
158754	/* 630 */ 300, 115, 116, 117, 59, 16, 250, 19, 192, 192,
158755	/* 640 */ 19, 23, 152, 153, 154, 24, 114, 309, 310, 192,
158756	/* 650 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
158757	/* 660 */ 112, 43, 44, 45, 46, 47, 48, 49, 50, 51,
158758	/* 670 */ 52, 53, 54, 55, 56, 57, 19, 7, 8, 9,
158759	/* 680 */ 23, 115, 116, 117, 203, 290, 239, 238, 137, 138,
158760	/* 690 */ 115, 116, 117, 236, 192, 22, 77, 81, 79, 250,
158761	/* 700 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
158762	/* 710 */ 53, 54, 55, 56, 57, 192, 95, 142, 237, 238,
158763	/* 720 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
158764	/* 730 */ 112, 250, 59, 112, 192, 119, 26, 214, 215, 118,
158765	/* 740 */ 119, 120, 121, 122, 123, 124, 19, 192, 267, 302,
158766	/* 750 */ 23, 130, 229, 137, 138, 23, 214, 215, 26, 102,
158767	/* 760 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
158768	/* 770 */ 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
158769	/* 780 */ 53, 54, 55, 56, 57, 19, 76, 11, 115, 116,
158770	/* 790 */ 117, 192, 29, 251, 239, 73, 33, 192, 192, 89,
158771	/* 800 */ 192, 192, 92, 192, 192, 126, 127, 128, 224, 43,
158772	/* 810 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
158773	/* 820 */ 54, 55, 56, 57, 192, 35, 214, 215, 65, 102,
158774	/* 830 */ 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
158775	/* 840 */ 59, 229, 192, 192, 239, 239, 214, 215, 126, 127,
158776	/* 850 */ 128, 126, 127, 128, 307, 19, 66, 302, 311, 192,
158777	/* 860 */ 261, 229, 224, 22, 74, 214, 215, 192, 102, 103,
158778	/* 870 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 43,
158779	/* 880 */ 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
158780	/* 890 */ 54, 55, 56, 57, 192, 192, 115, 116, 117, 19,
158781	/* 900 */ 59, 290, 251, 127, 128, 192, 23, 302, 302, 26,
158782	/* 910 */ 302, 236, 192, 22, 21, 24, 214, 215, 192, 129,
158783	/* 920 */ 22, 192, 24, 142, 158, 45, 46, 47, 48, 49,
158784	/* 930 */ 50, 51, 52, 53, 54, 55, 56, 57, 102, 103,
158785	/* 940 */ 104, 105, 106, 107, 108, 109, 110, 111, 112, 192,
158786	/* 950 */ 59, 12, 192, 251, 192, 305, 192, 116, 22, 23,
158787	/* 960 */ 242, 203, 26, 203, 24, 236, 27, 237, 238, 266,
158788	/* 970 */ 252, 214, 215, 80, 214, 215, 214, 215, 214, 215,
158789	/* 980 */ 250, 42, 102, 103, 104, 105, 106, 107, 108, 109,
158790	/* 990 */ 110, 111, 112, 229, 158, 237, 238, 237, 238, 59,
158791	/* 1000 */ 117, 281, 63, 192, 192, 192, 192, 116, 250, 192,
158792	/* 1010 */ 250, 251, 73, 251, 19, 122, 290, 237, 238, 24,
158793	/* 1020 */ 260, 209, 210, 209, 210, 142, 242, 214, 215, 197,
158794	/* 1030 */ 250, 22, 23, 276, 19, 26, 252, 101, 43, 44,
158795	/* 1040 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
158796	/* 1050 */ 55, 56, 57, 160, 19, 211, 116, 192, 43, 44,
158797	/* 1060 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
158798	/* 1070 */ 55, 56, 57, 192, 192, 22, 192, 266, 43, 44,
158799	/* 1080 */ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
158800	/* 1090 */ 55, 56, 57, 192, 282, 192, 282, 102, 103, 104,
158801	/* 1100 */ 105, 106, 107, 108, 109, 110, 111, 112, 59, 192,
158802	/* 1110 */ 101, 279, 192, 192, 230, 283, 192, 102, 103, 104,
158803	/* 1120 */ 105, 106, 107, 108, 109, 110, 111, 112, 204, 211,
158804	/* 1130 */ 66, 214, 215, 289, 214, 215, 108, 102, 103, 104,
158805	/* 1140 */ 105, 106, 107, 108, 109, 110, 111, 112, 266, 85,
158806	/* 1150 */ 226, 192, 228, 22, 23, 106, 107, 19, 94, 106,
158807	/* 1160 */ 107, 192, 134, 114, 115, 116, 117, 139, 119, 266,
158808	/* 1170 */ 203, 206, 207, 214, 215, 192, 127, 192, 206, 207,
158809	/* 1180 */ 59, 192, 44, 45, 46, 47, 48, 49, 50, 51,
158810	/* 1190 */ 52, 53, 54, 55, 56, 57, 192, 76, 192, 214,
158811	/* 1200 */ 215, 152, 284, 154, 237, 238, 192, 289, 87, 145,
158812	/* 1210 */ 89, 19, 20, 92, 22, 22, 23, 250, 307, 236,
158813	/* 1220 */ 214, 215, 311, 203, 12, 247, 192, 249, 36, 307,
158814	/* 1230 */ 192, 262, 101, 311, 137, 138, 115, 116, 117, 27,
158815	/* 1240 */ 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
158816	/* 1250 */ 112, 59, 214, 215, 42, 203, 307, 237, 238, 192,
158817	/* 1260 */ 311, 192, 26, 71, 192, 144, 262, 297, 298, 203,
158818	/* 1270 */ 250, 19, 20, 81, 22, 63, 262, 254, 255, 15,
158819	/* 1280 */ 26, 214, 215, 214, 215, 26, 214, 215, 36, 237,
158820	/* 1290 */ 238, 192, 100, 114, 101, 192, 262, 192, 106, 107,
158821	/* 1300 */ 48, 134, 250, 237, 238, 113, 139, 115, 116, 117,
158822	/* 1310 */ 192, 59, 120, 214, 215, 242, 250, 214, 215, 214,
158823	/* 1320 */ 215, 148, 149, 71, 60, 252, 242, 192, 149, 137,
158824	/* 1330 */ 138, 192, 214, 215, 192, 19, 252, 85, 192, 59,
158825	/* 1340 */ 192, 157, 90, 159, 152, 153, 154, 155, 156, 214,
158826	/* 1350 */ 215, 192, 100, 214, 215, 19, 214, 215, 106, 107,
158827	/* 1360 */ 214, 215, 214, 215, 22, 113, 192, 115, 116, 117,
158828	/* 1370 */ 192, 242, 120, 214, 215, 192, 24, 192, 31, 192,
158829	/* 1380 */ 144, 252, 26, 192, 125, 99, 39, 192, 214, 215,
158830	/* 1390 */ 192, 59, 214, 215, 192, 141, 116, 214, 215, 214,
158831	/* 1400 */ 215, 214, 215, 61, 152, 153, 154, 155, 156, 0,
158832	/* 1410 */ 1, 2, 214, 215, 5, 192, 214, 215, 132, 10,
158833	/* 1420 */ 11, 12, 13, 14, 1, 2, 17, 192, 5, 19,
158834	/* 1430 */ 20, 115, 22, 10, 11, 12, 13, 14, 192, 30,
158835	/* 1440 */ 17, 32, 23, 192, 23, 26, 36, 26, 116, 40,
158836	/* 1450 */ 192, 115, 192, 30, 192, 32, 119, 120, 59, 5,
158837	/* 1460 */ 214, 215, 128, 40, 10, 11, 12, 13, 14, 59,
158838	/* 1470 */ 19, 17, 214, 215, 214, 215, 214, 215, 120, 70,
158839	/* 1480 */ 192, 71, 22, 192, 30, 151, 32, 78, 130, 128,
158840	/* 1490 */ 81, 192, 140, 70, 40, 85, 192, 141, 7, 8,
158841	/* 1500 */ 90, 78, 214, 215, 81, 214, 215, 98, 83, 84,
158842	/* 1510 */ 100, 192, 151, 214, 215, 116, 106, 107, 214, 215,
158843	/* 1520 */ 192, 98, 192, 113, 70, 115, 116, 117, 23, 224,
158844	/* 1530 */ 120, 26, 78, 214, 215, 81, 19, 20, 152, 22,
158845	/* 1540 */ 154, 132, 214, 215, 214, 215, 137, 138, 97, 192,
158846	/* 1550 */ 256, 192, 98, 36, 23, 132, 192, 26, 192, 192,
158847	/* 1560 */ 137, 138, 152, 153, 154, 155, 156, 192, 192, 192,
158848	/* 1570 */ 161, 214, 215, 214, 215, 192, 59, 192, 214, 215,
158849	/* 1580 */ 214, 215, 192, 152, 161, 154, 132, 192, 71, 214,
158850	/* 1590 */ 215, 137, 138, 192, 192, 192, 19, 20, 192, 22,
158851	/* 1600 */ 140, 253, 85, 192, 214, 215, 192, 90, 23, 214,
158852	/* 1610 */ 215, 26, 192, 36, 192, 161, 23, 100, 192, 26,
158853	/* 1620 */ 214, 215, 192, 106, 107, 214, 215, 192, 23, 192,
158854	/* 1630 */ 113, 26, 115, 116, 117, 23, 59, 120, 26, 23,
158855	/* 1640 */ 23, 23, 26, 26, 26, 316, 234, 23, 71, 23,
158856	/* 1650 */ 26, 192, 26, 192, 192, 192, 192, 192, 192, 192,
158857	/* 1660 */ 192, 253, 212, 190, 286, 285, 253, 240, 253, 152,
158858	/* 1670 */ 153, 154, 155, 156, 241, 243, 295, 100, 291, 291,
158859	/* 1680 */ 223, 253, 227, 106, 107, 108, 269, 244, 244, 265,
158860	/* 1690 */ 113, 257, 115, 116, 117, 257, 243, 120, 269, 218,
158861	/* 1700 */ 217, 265, 217, 19, 20, 217, 22, 195, 269, 269,
158862	/* 1710 */ 60, 295, 140, 257, 243, 241, 247, 247, 199, 278,
158863	/* 1720 */ 36, 199, 199, 38, 19, 20, 150, 22, 149, 152,
158864	/* 1730 */ 153, 154, 155, 156, 22, 43, 232, 295, 292, 292,
158865	/* 1740 */ 18, 36, 235, 59, 268, 270, 235, 199, 235, 235,
158866	/* 1750 */ 18, 198, 148, 281, 244, 71, 270, 270, 268, 244,
158867	/* 1760 */ 232, 232, 244, 199, 59, 244, 198, 157, 288, 62,
158868	/* 1770 */ 199, 287, 198, 22, 219, 219, 71, 199, 198, 114,
158869	/* 1780 */ 199, 198, 216, 216, 100, 216, 225, 64, 22, 125,
158870	/* 1790 */ 106, 107, 222, 164, 219, 222, 24, 113, 216, 115,
158871	/* 1800 */ 116, 117, 218, 216, 120, 100, 216, 216, 310, 303,
158872	/* 1810 */ 112, 106, 107, 225, 280, 280, 219, 143, 113, 259,
158873	/* 1820 */ 115, 116, 117, 114, 259, 120, 199, 91, 82, 147,
158874	/* 1830 */ 144, 315, 22, 275, 199, 315, 152, 153, 154, 155,
158875	/* 1840 */ 156, 146, 145, 247, 258, 157, 25, 258, 245, 248,
158876	/* 1850 */ 244, 259, 258, 202, 259, 248, 258, 152, 153, 154,
158877	/* 1860 */ 155, 156, 263, 263, 26, 246, 13, 201, 193, 193,
158878	/* 1870 */ 6, 191, 191, 205, 191, 220, 220, 205, 211, 277,
158879	/* 1880 */ 211, 211, 211, 205, 4, 212, 3, 22, 162, 212,
158880	/* 1890 */ 211, 15, 23, 16, 23, 138, 129, 150, 26, 24,
158881	/* 1900 */ 141, 20, 16, 143, 1, 141, 129, 129, 61, 301,
158882	/* 1910 */ 301, 298, 150, 53, 53, 37, 53, 129, 115, 53,
158883	/* 1920 */ 140, 34, 1, 5, 22, 114, 68, 26, 160, 75,
158884	/* 1930 */ 68, 41, 140, 114, 24, 20, 19, 130, 124, 23,
158885	/* 1940 */ 67, 22, 22, 59, 22, 22, 67, 96, 24, 22,
158886	/* 1950 */ 37, 23, 67, 28, 148, 22, 26, 23, 23, 23,
158887	/* 1960 */ 23, 22, 140, 23, 97, 23, 34, 115, 22, 142,
158888	/* 1970 */ 26, 75, 34, 44, 75, 34, 88, 34, 86, 34,
158889	/* 1980 */ 23, 34, 93, 22, 24, 26, 34, 23, 26, 23,
158890	/* 1990 */ 23, 23, 23, 11, 23, 22, 26, 22, 22, 140,
158891	/* 2000 */ 23, 23, 22, 22, 134, 26, 23, 15, 140, 1,
158892	/* 2010 */ 1, 317, 317, 317, 140, 317, 317, 317, 317, 317,
158893	/* 2020 */ 317, 317, 140, 317, 317, 317, 317, 317, 317, 317,
158894	/* 2030 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158895	/* 2040 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158896	/* 2050 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158897	/* 2060 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158898	/* 2070 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158899	/* 2080 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158900	/* 2090 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158901	/* 2100 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158902	/* 2110 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158903	/* 2120 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158904	/* 2130 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158905	/* 2140 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158906	/* 2150 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158907	/* 2160 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158908	/* 2170 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158909	/* 2180 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158910	/* 2190 */ 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
158911	/* 2200 */ 317, 317, 317, 317, 317, 317, 317,
158912	};
158913	#define YY_SHIFT_COUNT (569)
158914	#define YY_SHIFT_MIN (0)
158915	#define YY_SHIFT_MAX (2009)
158916	static const unsigned short int yy_shift_ofst[] = {
158917	/* 0 */ 1423, 1409, 1454, 1192, 1192, 382, 1252, 1410, 1517, 1684,
158918	/* 10 */ 1684, 1684, 221, 0, 0, 180, 1015, 1684, 1684, 1684,
158919	/* 20 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158920	/* 30 */ 1049, 1049, 1121, 1121, 54, 616, 382, 382, 382, 382,
158921	/* 40 */ 382, 40, 110, 219, 289, 396, 439, 509, 548, 618,
158922	/* 50 */ 657, 727, 766, 836, 995, 1015, 1015, 1015, 1015, 1015,
158923	/* 60 */ 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015, 1015,
158924	/* 70 */ 1015, 1015, 1015, 1035, 1015, 1138, 880, 880, 1577, 1684,
158925	/* 80 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158926	/* 90 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158927	/* 100 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684, 1684,
158928	/* 110 */ 1684, 1684, 1684, 1705, 1684, 1684, 1684, 1684, 1684, 1684,
158929	/* 120 */ 1684, 1684, 1684, 1684, 1684, 1684, 1684, 146, 84, 84,
158930	/* 130 */ 84, 84, 84, 274, 315, 125, 97, 357, 66, 66,
158931	/* 140 */ 893, 258, 66, 66, 371, 371, 66, 551, 551, 551,
158932	/* 150 */ 551, 192, 209, 209, 278, 127, 2023, 2023, 621, 621,
158933	/* 160 */ 621, 201, 398, 398, 398, 398, 939, 939, 442, 936,
158934	/* 170 */ 1009, 66, 66, 66, 66, 66, 66, 66, 66, 66,
158935	/* 180 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
158936	/* 190 */ 66, 710, 710, 66, 776, 435, 435, 410, 410, 372,
158937	/* 200 */ 1097, 2023, 2023, 2023, 2023, 2023, 2023, 2023, 250, 490,
158938	/* 210 */ 490, 511, 451, 516, 252, 566, 575, 781, 673, 66,
158939	/* 220 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 722,
158940	/* 230 */ 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
158941	/* 240 */ 66, 66, 790, 790, 790, 66, 66, 66, 883, 66,
158942	/* 250 */ 66, 66, 891, 1064, 66, 66, 1212, 66, 66, 66,
158943	/* 260 */ 66, 66, 66, 66, 66, 725, 763, 177, 940, 940,
158944	/* 270 */ 940, 940, 337, 177, 177, 1028, 1053, 670, 1264, 1179,
158945	/* 280 */ 1173, 1254, 1316, 1173, 1316, 1336, 50, 1179, 1179, 50,
158946	/* 290 */ 1179, 1254, 1336, 1259, 732, 532, 1347, 1347, 1347, 1316,
158947	/* 300 */ 1236, 1236, 1184, 1356, 1167, 898, 1650, 1650, 1572, 1572,
158948	/* 310 */ 1685, 1685, 1572, 1576, 1579, 1712, 1692, 1722, 1722, 1722,
158949	/* 320 */ 1722, 1572, 1732, 1604, 1579, 1579, 1604, 1712, 1692, 1604,
158950	/* 330 */ 1692, 1604, 1572, 1732, 1610, 1707, 1572, 1732, 1751, 1572,
158951	/* 340 */ 1732, 1572, 1732, 1751, 1665, 1665, 1665, 1723, 1766, 1766,
158952	/* 350 */ 1751, 1665, 1664, 1665, 1723, 1665, 1665, 1629, 1772, 1698,
158953	/* 360 */ 1698, 1751, 1674, 1709, 1674, 1709, 1674, 1709, 1674, 1709,
158954	/* 370 */ 1572, 1736, 1736, 1746, 1746, 1682, 1686, 1810, 1572, 1688,
158955	/* 380 */ 1682, 1695, 1697, 1604, 1821, 1838, 1853, 1853, 1864, 1864,
158956	/* 390 */ 1864, 2023, 2023, 2023, 2023, 2023, 2023, 2023, 2023, 2023,
158957	/* 400 */ 2023, 2023, 2023, 2023, 2023, 2023, 232, 101, 1131, 1193,
158958	/* 410 */ 619, 679, 841, 1421, 1286, 115, 1352, 1334, 1361, 1419,
158959	/* 420 */ 1342, 1505, 1531, 1585, 1593, 1605, 1612, 1280, 1337, 1491,
158960	/* 430 */ 1358, 1451, 1332, 1616, 1617, 1425, 1618, 1386, 1431, 1624,
158961	/* 440 */ 1626, 1399, 1460, 1880, 1883, 1865, 1726, 1876, 1877, 1869,
158962	/* 450 */ 1871, 1757, 1747, 1767, 1872, 1872, 1875, 1759, 1881, 1760,
158963	/* 460 */ 1886, 1903, 1764, 1777, 1872, 1778, 1847, 1878, 1872, 1762,
158964	/* 470 */ 1860, 1861, 1863, 1866, 1788, 1803, 1887, 1780, 1921, 1918,
158965	/* 480 */ 1902, 1811, 1768, 1858, 1901, 1862, 1854, 1890, 1792, 1819,
158966	/* 490 */ 1910, 1915, 1917, 1807, 1814, 1919, 1873, 1920, 1922, 1916,
158967	/* 500 */ 1923, 1879, 1884, 1924, 1851, 1925, 1927, 1885, 1913, 1928,
158968	/* 510 */ 1806, 1933, 1934, 1935, 1936, 1930, 1937, 1939, 1867, 1822,
158969	/* 520 */ 1940, 1942, 1852, 1932, 1946, 1827, 1944, 1938, 1941, 1943,
158970	/* 530 */ 1945, 1888, 1896, 1892, 1929, 1899, 1889, 1947, 1957, 1961,
158971	/* 540 */ 1960, 1959, 1962, 1952, 1964, 1944, 1966, 1967, 1968, 1969,
158972	/* 550 */ 1970, 1971, 1973, 1982, 1975, 1976, 1977, 1978, 1980, 1981,
158973	/* 560 */ 1979, 1870, 1859, 1868, 1874, 1882, 1983, 1992, 2008, 2009,
158974	};
158975	#define YY_REDUCE_COUNT (405)
158976	#define YY_REDUCE_MIN (-266)
158977	#define YY_REDUCE_MAX (1683)
158978	static const short yy_reduce_ofst[] = {
158979	/* 0 */ 111, 168, 272, 760, -177, -175, -192, -190, -182, -179,
158980	/* 10 */ 216, 220, 481, -208, -205, -266, -140, -115, 241, 393,
158981	/* 20 */ 523, 325, 612, 632, 542, 651, 764, 757, 702, 762,
158982	/* 30 */ 812, 814, -188, 273, 924, 386, 758, 967, 1020, 1052,
158983	/* 40 */ 1066, -256, -256, -256, -256, -256, -256, -256, -256, -256,
158984	/* 50 */ -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
158985	/* 60 */ -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
158986	/* 70 */ -256, -256, -256, -256, -256, -256, -256, -256, 195, 222,
158987	/* 80 */ 813, 917, 920, 959, 985, 1006, 1038, 1067, 1069, 1072,
158988	/* 90 */ 1099, 1103, 1105, 1118, 1135, 1139, 1142, 1146, 1148, 1159,
158989	/* 100 */ 1174, 1178, 1183, 1185, 1187, 1198, 1202, 1246, 1258, 1260,
158990	/* 110 */ 1262, 1288, 1291, 1299, 1304, 1319, 1328, 1330, 1357, 1359,
158991	/* 120 */ 1364, 1366, 1375, 1390, 1395, 1406, 1411, -256, -256, -256,
158992	/* 130 */ -256, -256, -256, -256, -256, 447, -256, 555, -178, 605,
158993	/* 140 */ 832, -220, 606, -94, -168, 36, -122, 730, 780, 730,
158994	/* 150 */ 780, 918, -136, 338, -256, -256, -256, -256, 80, 80,
158995	/* 160 */ 80, 720, 703, 811, 882, 903, -213, -204, 106, 330,
158996	/* 170 */ 330, -77, 236, 320, 599, 67, 457, 675, 729, 395,
158997	/* 180 */ 268, 611, 969, 1004, 726, 1014, 983, 123, 884, 608,
158998	/* 190 */ 1034, 547, 911, 650, 844, 922, 949, 965, 972, 978,
158999	/* 200 */ 449, 970, 718, 784, 1073, 1084, 1023, 1129, -209, -180,
159000	/* 210 */ -113, 114, 183, 329, 345, 391, 446, 502, 609, 667,
159001	/* 220 */ 713, 817, 865, 881, 901, 921, 989, 1191, 1195, 214,
159002	/* 230 */ 1223, 1235, 1251, 1367, 1376, 1377, 1383, 1385, 1401, 1402,
159003	/* 240 */ 1403, 1414, 584, 638, 1305, 1420, 1422, 1426, 1294, 1430,
159004	/* 250 */ 1435, 1437, 1348, 1329, 1459, 1461, 1412, 1462, 345, 1463,
159005	/* 260 */ 1464, 1465, 1466, 1467, 1468, 1378, 1380, 1427, 1408, 1413,
159006	/* 270 */ 1415, 1428, 1294, 1427, 1427, 1433, 1450, 1473, 1381, 1417,
159007	/* 280 */ 1424, 1432, 1434, 1436, 1438, 1387, 1443, 1429, 1439, 1444,
159008	/* 290 */ 1440, 1453, 1388, 1481, 1455, 1457, 1483, 1485, 1488, 1456,
159009	/* 300 */ 1469, 1470, 1441, 1471, 1474, 1512, 1416, 1442, 1519, 1522,
159010	/* 310 */ 1446, 1447, 1523, 1472, 1475, 1476, 1504, 1507, 1511, 1513,
159011	/* 320 */ 1514, 1548, 1553, 1510, 1486, 1487, 1515, 1490, 1528, 1518,
159012	/* 330 */ 1529, 1521, 1564, 1568, 1480, 1484, 1571, 1574, 1555, 1578,
159013	/* 340 */ 1580, 1581, 1583, 1556, 1566, 1567, 1569, 1561, 1570, 1573,
159014	/* 350 */ 1575, 1582, 1584, 1587, 1588, 1590, 1591, 1498, 1506, 1534,
159015	/* 360 */ 1535, 1597, 1560, 1586, 1565, 1589, 1592, 1594, 1595, 1598,
159016	/* 370 */ 1627, 1516, 1520, 1599, 1600, 1601, 1596, 1558, 1635, 1602,
159017	/* 380 */ 1607, 1619, 1603, 1606, 1651, 1666, 1675, 1676, 1680, 1681,
159018	/* 390 */ 1683, 1608, 1609, 1613, 1668, 1667, 1669, 1670, 1671, 1672,
159019	/* 400 */ 1655, 1656, 1673, 1677, 1679, 1678,
159020	};
159021	static const YYACTIONTYPE yy_default[] = {
159022	/* 0 */ 1623, 1623, 1623, 1453, 1223, 1332, 1223, 1223, 1223, 1453,
159023	/* 10 */ 1453, 1453, 1223, 1362, 1362, 1506, 1254, 1223, 1223, 1223,
159024	/* 20 */ 1223, 1223, 1223, 1223, 1223, 1223, 1223, 1452, 1223, 1223,
	@@ -159112,10 +159274,11 @@
159274	0, /* VECTOR => nothing */
159275	0, /* SELECT_COLUMN => nothing */
159276	0, /* IF_NULL_ROW => nothing */
159277	0, /* ASTERISK => nothing */
159278	0, /* SPAN => nothing */
159279	0, /* ERROR => nothing */
159280	0, /* SPACE => nothing */
159281	0, /* ILLEGAL => nothing */
159282	};
159283	#endif /* YYFALLBACK */
159284
	@@ -159383,145 +159546,146 @@
159546	/* 176 */ "VECTOR",
159547	/* 177 */ "SELECT_COLUMN",
159548	/* 178 */ "IF_NULL_ROW",
159549	/* 179 */ "ASTERISK",
159550	/* 180 */ "SPAN",
159551	/* 181 */ "ERROR",
159552	/* 182 */ "SPACE",
159553	/* 183 */ "ILLEGAL",
159554	/* 184 */ "input",
159555	/* 185 */ "cmdlist",
159556	/* 186 */ "ecmd",
159557	/* 187 */ "cmdx",
159558	/* 188 */ "explain",
159559	/* 189 */ "cmd",
159560	/* 190 */ "transtype",
159561	/* 191 */ "trans_opt",
159562	/* 192 */ "nm",
159563	/* 193 */ "savepoint_opt",
159564	/* 194 */ "create_table",
159565	/* 195 */ "create_table_args",
159566	/* 196 */ "createkw",
159567	/* 197 */ "temp",
159568	/* 198 */ "ifnotexists",
159569	/* 199 */ "dbnm",
159570	/* 200 */ "columnlist",
159571	/* 201 */ "conslist_opt",
159572	/* 202 */ "table_options",
159573	/* 203 */ "select",
159574	/* 204 */ "columnname",
159575	/* 205 */ "carglist",
159576	/* 206 */ "typetoken",
159577	/* 207 */ "typename",
159578	/* 208 */ "signed",
159579	/* 209 */ "plus_num",
159580	/* 210 */ "minus_num",
159581	/* 211 */ "scanpt",
159582	/* 212 */ "scantok",
159583	/* 213 */ "ccons",
159584	/* 214 */ "term",
159585	/* 215 */ "expr",
159586	/* 216 */ "onconf",
159587	/* 217 */ "sortorder",
159588	/* 218 */ "autoinc",
159589	/* 219 */ "eidlist_opt",
159590	/* 220 */ "refargs",
159591	/* 221 */ "defer_subclause",
159592	/* 222 */ "generated",
159593	/* 223 */ "refarg",
159594	/* 224 */ "refact",
159595	/* 225 */ "init_deferred_pred_opt",
159596	/* 226 */ "conslist",
159597	/* 227 */ "tconscomma",
159598	/* 228 */ "tcons",
159599	/* 229 */ "sortlist",
159600	/* 230 */ "eidlist",
159601	/* 231 */ "defer_subclause_opt",
159602	/* 232 */ "orconf",
159603	/* 233 */ "resolvetype",
159604	/* 234 */ "raisetype",
159605	/* 235 */ "ifexists",
159606	/* 236 */ "fullname",
159607	/* 237 */ "selectnowith",
159608	/* 238 */ "oneselect",
159609	/* 239 */ "wqlist",
159610	/* 240 */ "multiselect_op",
159611	/* 241 */ "distinct",
159612	/* 242 */ "selcollist",
159613	/* 243 */ "from",
159614	/* 244 */ "where_opt",
159615	/* 245 */ "groupby_opt",
159616	/* 246 */ "having_opt",
159617	/* 247 */ "orderby_opt",
159618	/* 248 */ "limit_opt",
159619	/* 249 */ "window_clause",
159620	/* 250 */ "values",
159621	/* 251 */ "nexprlist",
159622	/* 252 */ "sclp",
159623	/* 253 */ "as",
159624	/* 254 */ "seltablist",
159625	/* 255 */ "stl_prefix",
159626	/* 256 */ "joinop",
159627	/* 257 */ "indexed_opt",
159628	/* 258 */ "on_opt",
159629	/* 259 */ "using_opt",
159630	/* 260 */ "exprlist",
159631	/* 261 */ "xfullname",
159632	/* 262 */ "idlist",
159633	/* 263 */ "nulls",
159634	/* 264 */ "with",
159635	/* 265 */ "where_opt_ret",
159636	/* 266 */ "setlist",
159637	/* 267 */ "insert_cmd",
159638	/* 268 */ "idlist_opt",
159639	/* 269 */ "upsert",
159640	/* 270 */ "returning",
159641	/* 271 */ "filter_over",
159642	/* 272 */ "likeop",
159643	/* 273 */ "between_op",
159644	/* 274 */ "in_op",
159645	/* 275 */ "paren_exprlist",
159646	/* 276 */ "case_operand",
159647	/* 277 */ "case_exprlist",
159648	/* 278 */ "case_else",
159649	/* 279 */ "uniqueflag",
159650	/* 280 */ "collate",
159651	/* 281 */ "vinto",
159652	/* 282 */ "nmnum",
159653	/* 283 */ "trigger_decl",
159654	/* 284 */ "trigger_cmd_list",
159655	/* 285 */ "trigger_time",
159656	/* 286 */ "trigger_event",
159657	/* 287 */ "foreach_clause",
159658	/* 288 */ "when_clause",
159659	/* 289 */ "trigger_cmd",
159660	/* 290 */ "trnm",
159661	/* 291 */ "tridxby",
159662	/* 292 */ "database_kw_opt",
159663	/* 293 */ "key_opt",
159664	/* 294 */ "add_column_fullname",
159665	/* 295 */ "kwcolumn_opt",
159666	/* 296 */ "create_vtab",
159667	/* 297 */ "vtabarglist",
159668	/* 298 */ "vtabarg",
159669	/* 299 */ "vtabargtoken",
159670	/* 300 */ "lp",
159671	/* 301 */ "anylist",
159672	/* 302 */ "wqitem",
159673	/* 303 */ "wqas",
159674	/* 304 */ "windowdefn_list",
159675	/* 305 */ "windowdefn",
159676	/* 306 */ "window",
159677	/* 307 */ "frame_opt",
159678	/* 308 */ "part_opt",
159679	/* 309 */ "filter_clause",
159680	/* 310 */ "over_clause",
159681	/* 311 */ "range_or_rows",
159682	/* 312 */ "frame_bound",
159683	/* 313 */ "frame_bound_s",
159684	/* 314 */ "frame_bound_e",
159685	/* 315 */ "frame_exclude_opt",
159686	/* 316 */ "frame_exclude",
159687	};
159688	#endif /* defined(YYCOVERAGE) \|\| !defined(NDEBUG) */
159689
159690	#ifndef NDEBUG
159691	/* For tracing reduce actions, the names of all rules are required.
	@@ -160048,103 +160212,103 @@
160212	** Note: during a reduce, the only symbols destroyed are those
160213	** which appear on the RHS of the rule, but which are not used
160214	** inside the C code.
160215	*/
160216	/******* Begin destructor definitions *************************************/
160217	case 203: /* select */
160218	case 237: /* selectnowith */
160219	case 238: /* oneselect */
160220	case 250: /* values */
160221	{
160222	sqlite3SelectDelete(pParse->db, (yypminor->yy81));
160223	}
160224	break;
160225	case 214: /* term */
160226	case 215: /* expr */
160227	case 244: /* where_opt */
160228	case 246: /* having_opt */
160229	case 258: /* on_opt */
160230	case 265: /* where_opt_ret */
160231	case 276: /* case_operand */
160232	case 278: /* case_else */
160233	case 281: /* vinto */
160234	case 288: /* when_clause */
160235	case 293: /* key_opt */
160236	case 309: /* filter_clause */
160237	{
160238	sqlite3ExprDelete(pParse->db, (yypminor->yy404));
160239	}
160240	break;
160241	case 219: /* eidlist_opt */
160242	case 229: /* sortlist */
160243	case 230: /* eidlist */
160244	case 242: /* selcollist */
160245	case 245: /* groupby_opt */
160246	case 247: /* orderby_opt */
160247	case 251: /* nexprlist */
160248	case 252: /* sclp */
160249	case 260: /* exprlist */
160250	case 266: /* setlist */
160251	case 275: /* paren_exprlist */
160252	case 277: /* case_exprlist */
160253	case 308: /* part_opt */
160254	{
160255	sqlite3ExprListDelete(pParse->db, (yypminor->yy70));
160256	}
160257	break;
160258	case 236: /* fullname */
160259	case 243: /* from */
160260	case 254: /* seltablist */
160261	case 255: /* stl_prefix */
160262	case 261: /* xfullname */
160263	{
160264	sqlite3SrcListDelete(pParse->db, (yypminor->yy153));
160265	}
160266	break;
160267	case 239: /* wqlist */
160268	{
160269	sqlite3WithDelete(pParse->db, (yypminor->yy103));
160270	}
160271	break;
160272	case 249: /* window_clause */
160273	case 304: /* windowdefn_list */
160274	{
160275	sqlite3WindowListDelete(pParse->db, (yypminor->yy49));
160276	}
160277	break;
160278	case 259: /* using_opt */
160279	case 262: /* idlist */
160280	case 268: /* idlist_opt */
160281	{
160282	sqlite3IdListDelete(pParse->db, (yypminor->yy436));
160283	}
160284	break;
160285	case 271: /* filter_over */
160286	case 305: /* windowdefn */
160287	case 306: /* window */
160288	case 307: /* frame_opt */
160289	case 310: /* over_clause */
160290	{
160291	sqlite3WindowDelete(pParse->db, (yypminor->yy49));
160292	}
160293	break;
160294	case 284: /* trigger_cmd_list */
160295	case 289: /* trigger_cmd */
160296	{
160297	sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy157));
160298	}
160299	break;
160300	case 286: /* trigger_event */
160301	{
160302	sqlite3IdListDelete(pParse->db, (yypminor->yy262).b);
160303	}
160304	break;
160305	case 312: /* frame_bound */
160306	case 313: /* frame_bound_s */
160307	case 314: /* frame_bound_e */
160308	{
160309	sqlite3ExprDelete(pParse->db, (yypminor->yy117).pExpr);
160310	}
160311	break;
160312	/******* End destructor definitions ***************************************/
160313	default: break; /* If no destructor action specified: do nothing */
160314	}
	@@ -160431,408 +160595,408 @@
160595	}
160596
160597	/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
160598	** of that rule */
160599	static const YYCODETYPE yyRuleInfoLhs[] = {
160600	188, /* (0) explain ::= EXPLAIN */
160601	188, /* (1) explain ::= EXPLAIN QUERY PLAN */
160602	187, /* (2) cmdx ::= cmd */
160603	189, /* (3) cmd ::= BEGIN transtype trans_opt */
160604	190, /* (4) transtype ::= */
160605	190, /* (5) transtype ::= DEFERRED */
160606	190, /* (6) transtype ::= IMMEDIATE */
160607	190, /* (7) transtype ::= EXCLUSIVE */
160608	189, /* (8) cmd ::= COMMIT\|END trans_opt */
160609	189, /* (9) cmd ::= ROLLBACK trans_opt */
160610	189, /* (10) cmd ::= SAVEPOINT nm */
160611	189, /* (11) cmd ::= RELEASE savepoint_opt nm */
160612	189, /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
160613	194, /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
160614	196, /* (14) createkw ::= CREATE */
160615	198, /* (15) ifnotexists ::= */
160616	198, /* (16) ifnotexists ::= IF NOT EXISTS */
160617	197, /* (17) temp ::= TEMP */
160618	197, /* (18) temp ::= */
160619	195, /* (19) create_table_args ::= LP columnlist conslist_opt RP table_options */
160620	195, /* (20) create_table_args ::= AS select */
160621	202, /* (21) table_options ::= */
160622	202, /* (22) table_options ::= WITHOUT nm */
160623	204, /* (23) columnname ::= nm typetoken */
160624	206, /* (24) typetoken ::= */
160625	206, /* (25) typetoken ::= typename LP signed RP */
160626	206, /* (26) typetoken ::= typename LP signed COMMA signed RP */
160627	207, /* (27) typename ::= typename ID\|STRING */
160628	211, /* (28) scanpt ::= */
160629	212, /* (29) scantok ::= */
160630	213, /* (30) ccons ::= CONSTRAINT nm */
160631	213, /* (31) ccons ::= DEFAULT scantok term */
160632	213, /* (32) ccons ::= DEFAULT LP expr RP */
160633	213, /* (33) ccons ::= DEFAULT PLUS scantok term */
160634	213, /* (34) ccons ::= DEFAULT MINUS scantok term */
160635	213, /* (35) ccons ::= DEFAULT scantok ID\|INDEXED */
160636	213, /* (36) ccons ::= NOT NULL onconf */
160637	213, /* (37) ccons ::= PRIMARY KEY sortorder onconf autoinc */
160638	213, /* (38) ccons ::= UNIQUE onconf */
160639	213, /* (39) ccons ::= CHECK LP expr RP */
160640	213, /* (40) ccons ::= REFERENCES nm eidlist_opt refargs */
160641	213, /* (41) ccons ::= defer_subclause */
160642	213, /* (42) ccons ::= COLLATE ID\|STRING */
160643	222, /* (43) generated ::= LP expr RP */
160644	222, /* (44) generated ::= LP expr RP ID */
160645	218, /* (45) autoinc ::= */
160646	218, /* (46) autoinc ::= AUTOINCR */
160647	220, /* (47) refargs ::= */
160648	220, /* (48) refargs ::= refargs refarg */
160649	223, /* (49) refarg ::= MATCH nm */
160650	223, /* (50) refarg ::= ON INSERT refact */
160651	223, /* (51) refarg ::= ON DELETE refact */
160652	223, /* (52) refarg ::= ON UPDATE refact */
160653	224, /* (53) refact ::= SET NULL */
160654	224, /* (54) refact ::= SET DEFAULT */
160655	224, /* (55) refact ::= CASCADE */
160656	224, /* (56) refact ::= RESTRICT */
160657	224, /* (57) refact ::= NO ACTION */
160658	221, /* (58) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
160659	221, /* (59) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
160660	225, /* (60) init_deferred_pred_opt ::= */
160661	225, /* (61) init_deferred_pred_opt ::= INITIALLY DEFERRED */
160662	225, /* (62) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
160663	201, /* (63) conslist_opt ::= */
160664	227, /* (64) tconscomma ::= COMMA */
160665	228, /* (65) tcons ::= CONSTRAINT nm */
160666	228, /* (66) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
160667	228, /* (67) tcons ::= UNIQUE LP sortlist RP onconf */
160668	228, /* (68) tcons ::= CHECK LP expr RP onconf */
160669	228, /* (69) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
160670	231, /* (70) defer_subclause_opt ::= */
160671	216, /* (71) onconf ::= */
160672	216, /* (72) onconf ::= ON CONFLICT resolvetype */
160673	232, /* (73) orconf ::= */
160674	232, /* (74) orconf ::= OR resolvetype */
160675	233, /* (75) resolvetype ::= IGNORE */
160676	233, /* (76) resolvetype ::= REPLACE */
160677	189, /* (77) cmd ::= DROP TABLE ifexists fullname */
160678	235, /* (78) ifexists ::= IF EXISTS */
160679	235, /* (79) ifexists ::= */
160680	189, /* (80) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
160681	189, /* (81) cmd ::= DROP VIEW ifexists fullname */
160682	189, /* (82) cmd ::= select */
160683	203, /* (83) select ::= WITH wqlist selectnowith */
160684	203, /* (84) select ::= WITH RECURSIVE wqlist selectnowith */
160685	203, /* (85) select ::= selectnowith */
160686	237, /* (86) selectnowith ::= selectnowith multiselect_op oneselect */
160687	240, /* (87) multiselect_op ::= UNION */
160688	240, /* (88) multiselect_op ::= UNION ALL */
160689	240, /* (89) multiselect_op ::= EXCEPT\|INTERSECT */
160690	238, /* (90) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
160691	238, /* (91) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
160692	250, /* (92) values ::= VALUES LP nexprlist RP */
160693	250, /* (93) values ::= values COMMA LP nexprlist RP */
160694	241, /* (94) distinct ::= DISTINCT */
160695	241, /* (95) distinct ::= ALL */
160696	241, /* (96) distinct ::= */
160697	252, /* (97) sclp ::= */
160698	242, /* (98) selcollist ::= sclp scanpt expr scanpt as */
160699	242, /* (99) selcollist ::= sclp scanpt STAR */
160700	242, /* (100) selcollist ::= sclp scanpt nm DOT STAR */
160701	253, /* (101) as ::= AS nm */
160702	253, /* (102) as ::= */
160703	243, /* (103) from ::= */
160704	243, /* (104) from ::= FROM seltablist */
160705	255, /* (105) stl_prefix ::= seltablist joinop */
160706	255, /* (106) stl_prefix ::= */
160707	254, /* (107) seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
160708	254, /* (108) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
160709	254, /* (109) seltablist ::= stl_prefix LP select RP as on_opt using_opt */
160710	254, /* (110) seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
160711	199, /* (111) dbnm ::= */
160712	199, /* (112) dbnm ::= DOT nm */
160713	236, /* (113) fullname ::= nm */
160714	236, /* (114) fullname ::= nm DOT nm */
160715	261, /* (115) xfullname ::= nm */
160716	261, /* (116) xfullname ::= nm DOT nm */
160717	261, /* (117) xfullname ::= nm DOT nm AS nm */
160718	261, /* (118) xfullname ::= nm AS nm */
160719	256, /* (119) joinop ::= COMMA\|JOIN */
160720	256, /* (120) joinop ::= JOIN_KW JOIN */
160721	256, /* (121) joinop ::= JOIN_KW nm JOIN */
160722	256, /* (122) joinop ::= JOIN_KW nm nm JOIN */
160723	258, /* (123) on_opt ::= ON expr */
160724	258, /* (124) on_opt ::= */
160725	257, /* (125) indexed_opt ::= */
160726	257, /* (126) indexed_opt ::= INDEXED BY nm */
160727	257, /* (127) indexed_opt ::= NOT INDEXED */
160728	259, /* (128) using_opt ::= USING LP idlist RP */
160729	259, /* (129) using_opt ::= */
160730	247, /* (130) orderby_opt ::= */
160731	247, /* (131) orderby_opt ::= ORDER BY sortlist */
160732	229, /* (132) sortlist ::= sortlist COMMA expr sortorder nulls */
160733	229, /* (133) sortlist ::= expr sortorder nulls */
160734	217, /* (134) sortorder ::= ASC */
160735	217, /* (135) sortorder ::= DESC */
160736	217, /* (136) sortorder ::= */
160737	263, /* (137) nulls ::= NULLS FIRST */
160738	263, /* (138) nulls ::= NULLS LAST */
160739	263, /* (139) nulls ::= */
160740	245, /* (140) groupby_opt ::= */
160741	245, /* (141) groupby_opt ::= GROUP BY nexprlist */
160742	246, /* (142) having_opt ::= */
160743	246, /* (143) having_opt ::= HAVING expr */
160744	248, /* (144) limit_opt ::= */
160745	248, /* (145) limit_opt ::= LIMIT expr */
160746	248, /* (146) limit_opt ::= LIMIT expr OFFSET expr */
160747	248, /* (147) limit_opt ::= LIMIT expr COMMA expr */
160748	189, /* (148) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
160749	244, /* (149) where_opt ::= */
160750	244, /* (150) where_opt ::= WHERE expr */
160751	265, /* (151) where_opt_ret ::= */
160752	265, /* (152) where_opt_ret ::= WHERE expr */
160753	265, /* (153) where_opt_ret ::= RETURNING selcollist */
160754	265, /* (154) where_opt_ret ::= WHERE expr RETURNING selcollist */
160755	189, /* (155) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
160756	266, /* (156) setlist ::= setlist COMMA nm EQ expr */
160757	266, /* (157) setlist ::= setlist COMMA LP idlist RP EQ expr */
160758	266, /* (158) setlist ::= nm EQ expr */
160759	266, /* (159) setlist ::= LP idlist RP EQ expr */
160760	189, /* (160) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
160761	189, /* (161) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
160762	269, /* (162) upsert ::= */
160763	269, /* (163) upsert ::= RETURNING selcollist */
160764	269, /* (164) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
160765	269, /* (165) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
160766	269, /* (166) upsert ::= ON CONFLICT DO NOTHING returning */
160767	269, /* (167) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
160768	270, /* (168) returning ::= RETURNING selcollist */
160769	267, /* (169) insert_cmd ::= INSERT orconf */
160770	267, /* (170) insert_cmd ::= REPLACE */
160771	268, /* (171) idlist_opt ::= */
160772	268, /* (172) idlist_opt ::= LP idlist RP */
160773	262, /* (173) idlist ::= idlist COMMA nm */
160774	262, /* (174) idlist ::= nm */
160775	215, /* (175) expr ::= LP expr RP */
160776	215, /* (176) expr ::= ID\|INDEXED */
160777	215, /* (177) expr ::= JOIN_KW */
160778	215, /* (178) expr ::= nm DOT nm */
160779	215, /* (179) expr ::= nm DOT nm DOT nm */
160780	214, /* (180) term ::= NULL\|FLOAT\|BLOB */
160781	214, /* (181) term ::= STRING */
160782	214, /* (182) term ::= INTEGER */
160783	215, /* (183) expr ::= VARIABLE */
160784	215, /* (184) expr ::= expr COLLATE ID\|STRING */
160785	215, /* (185) expr ::= CAST LP expr AS typetoken RP */
160786	215, /* (186) expr ::= ID\|INDEXED LP distinct exprlist RP */
160787	215, /* (187) expr ::= ID\|INDEXED LP STAR RP */
160788	215, /* (188) expr ::= ID\|INDEXED LP distinct exprlist RP filter_over */
160789	215, /* (189) expr ::= ID\|INDEXED LP STAR RP filter_over */
160790	214, /* (190) term ::= CTIME_KW */
160791	215, /* (191) expr ::= LP nexprlist COMMA expr RP */
160792	215, /* (192) expr ::= expr AND expr */
160793	215, /* (193) expr ::= expr OR expr */
160794	215, /* (194) expr ::= expr LT\|GT\|GE\|LE expr */
160795	215, /* (195) expr ::= expr EQ\|NE expr */
160796	215, /* (196) expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */
160797	215, /* (197) expr ::= expr PLUS\|MINUS expr */
160798	215, /* (198) expr ::= expr STAR\|SLASH\|REM expr */
160799	215, /* (199) expr ::= expr CONCAT expr */
160800	272, /* (200) likeop ::= NOT LIKE_KW\|MATCH */
160801	215, /* (201) expr ::= expr likeop expr */
160802	215, /* (202) expr ::= expr likeop expr ESCAPE expr */
160803	215, /* (203) expr ::= expr ISNULL\|NOTNULL */
160804	215, /* (204) expr ::= expr NOT NULL */
160805	215, /* (205) expr ::= expr IS expr */
160806	215, /* (206) expr ::= expr IS NOT expr */
160807	215, /* (207) expr ::= NOT expr */
160808	215, /* (208) expr ::= BITNOT expr */
160809	215, /* (209) expr ::= PLUS\|MINUS expr */
160810	273, /* (210) between_op ::= BETWEEN */
160811	273, /* (211) between_op ::= NOT BETWEEN */
160812	215, /* (212) expr ::= expr between_op expr AND expr */
160813	274, /* (213) in_op ::= IN */
160814	274, /* (214) in_op ::= NOT IN */
160815	215, /* (215) expr ::= expr in_op LP exprlist RP */
160816	215, /* (216) expr ::= LP select RP */
160817	215, /* (217) expr ::= expr in_op LP select RP */
160818	215, /* (218) expr ::= expr in_op nm dbnm paren_exprlist */
160819	215, /* (219) expr ::= EXISTS LP select RP */
160820	215, /* (220) expr ::= CASE case_operand case_exprlist case_else END */
160821	277, /* (221) case_exprlist ::= case_exprlist WHEN expr THEN expr */
160822	277, /* (222) case_exprlist ::= WHEN expr THEN expr */
160823	278, /* (223) case_else ::= ELSE expr */
160824	278, /* (224) case_else ::= */
160825	276, /* (225) case_operand ::= expr */
160826	276, /* (226) case_operand ::= */
160827	260, /* (227) exprlist ::= */
160828	251, /* (228) nexprlist ::= nexprlist COMMA expr */
160829	251, /* (229) nexprlist ::= expr */
160830	275, /* (230) paren_exprlist ::= */
160831	275, /* (231) paren_exprlist ::= LP exprlist RP */
160832	189, /* (232) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
160833	279, /* (233) uniqueflag ::= UNIQUE */
160834	279, /* (234) uniqueflag ::= */
160835	219, /* (235) eidlist_opt ::= */
160836	219, /* (236) eidlist_opt ::= LP eidlist RP */
160837	230, /* (237) eidlist ::= eidlist COMMA nm collate sortorder */
160838	230, /* (238) eidlist ::= nm collate sortorder */
160839	280, /* (239) collate ::= */
160840	280, /* (240) collate ::= COLLATE ID\|STRING */
160841	189, /* (241) cmd ::= DROP INDEX ifexists fullname */
160842	189, /* (242) cmd ::= VACUUM vinto */
160843	189, /* (243) cmd ::= VACUUM nm vinto */
160844	281, /* (244) vinto ::= INTO expr */
160845	281, /* (245) vinto ::= */
160846	189, /* (246) cmd ::= PRAGMA nm dbnm */
160847	189, /* (247) cmd ::= PRAGMA nm dbnm EQ nmnum */
160848	189, /* (248) cmd ::= PRAGMA nm dbnm LP nmnum RP */
160849	189, /* (249) cmd ::= PRAGMA nm dbnm EQ minus_num */
160850	189, /* (250) cmd ::= PRAGMA nm dbnm LP minus_num RP */
160851	209, /* (251) plus_num ::= PLUS INTEGER\|FLOAT */
160852	210, /* (252) minus_num ::= MINUS INTEGER\|FLOAT */
160853	189, /* (253) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
160854	283, /* (254) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
160855	285, /* (255) trigger_time ::= BEFORE\|AFTER */
160856	285, /* (256) trigger_time ::= INSTEAD OF */
160857	285, /* (257) trigger_time ::= */
160858	286, /* (258) trigger_event ::= DELETE\|INSERT */
160859	286, /* (259) trigger_event ::= UPDATE */
160860	286, /* (260) trigger_event ::= UPDATE OF idlist */
160861	288, /* (261) when_clause ::= */
160862	288, /* (262) when_clause ::= WHEN expr */
160863	284, /* (263) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
160864	284, /* (264) trigger_cmd_list ::= trigger_cmd SEMI */
160865	290, /* (265) trnm ::= nm DOT nm */
160866	291, /* (266) tridxby ::= INDEXED BY nm */
160867	291, /* (267) tridxby ::= NOT INDEXED */
160868	289, /* (268) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
160869	289, /* (269) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
160870	289, /* (270) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
160871	289, /* (271) trigger_cmd ::= scanpt select scanpt */
160872	215, /* (272) expr ::= RAISE LP IGNORE RP */
160873	215, /* (273) expr ::= RAISE LP raisetype COMMA nm RP */
160874	234, /* (274) raisetype ::= ROLLBACK */
160875	234, /* (275) raisetype ::= ABORT */
160876	234, /* (276) raisetype ::= FAIL */
160877	189, /* (277) cmd ::= DROP TRIGGER ifexists fullname */
160878	189, /* (278) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
160879	189, /* (279) cmd ::= DETACH database_kw_opt expr */
160880	293, /* (280) key_opt ::= */
160881	293, /* (281) key_opt ::= KEY expr */
160882	189, /* (282) cmd ::= REINDEX */
160883	189, /* (283) cmd ::= REINDEX nm dbnm */
160884	189, /* (284) cmd ::= ANALYZE */
160885	189, /* (285) cmd ::= ANALYZE nm dbnm */
160886	189, /* (286) cmd ::= ALTER TABLE fullname RENAME TO nm */
160887	189, /* (287) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
160888	189, /* (288) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
160889	294, /* (289) add_column_fullname ::= fullname */
160890	189, /* (290) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
160891	189, /* (291) cmd ::= create_vtab */
160892	189, /* (292) cmd ::= create_vtab LP vtabarglist RP */
160893	296, /* (293) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
160894	298, /* (294) vtabarg ::= */
160895	299, /* (295) vtabargtoken ::= ANY */
160896	299, /* (296) vtabargtoken ::= lp anylist RP */
160897	300, /* (297) lp ::= LP */
160898	264, /* (298) with ::= WITH wqlist */
160899	264, /* (299) with ::= WITH RECURSIVE wqlist */
160900	303, /* (300) wqas ::= AS */
160901	303, /* (301) wqas ::= AS MATERIALIZED */
160902	303, /* (302) wqas ::= AS NOT MATERIALIZED */
160903	302, /* (303) wqitem ::= nm eidlist_opt wqas LP select RP */
160904	239, /* (304) wqlist ::= wqitem */
160905	239, /* (305) wqlist ::= wqlist COMMA wqitem */
160906	304, /* (306) windowdefn_list ::= windowdefn */
160907	304, /* (307) windowdefn_list ::= windowdefn_list COMMA windowdefn */
160908	305, /* (308) windowdefn ::= nm AS LP window RP */
160909	306, /* (309) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
160910	306, /* (310) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
160911	306, /* (311) window ::= ORDER BY sortlist frame_opt */
160912	306, /* (312) window ::= nm ORDER BY sortlist frame_opt */
160913	306, /* (313) window ::= frame_opt */
160914	306, /* (314) window ::= nm frame_opt */
160915	307, /* (315) frame_opt ::= */
160916	307, /* (316) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
160917	307, /* (317) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
160918	311, /* (318) range_or_rows ::= RANGE\|ROWS\|GROUPS */
160919	313, /* (319) frame_bound_s ::= frame_bound */
160920	313, /* (320) frame_bound_s ::= UNBOUNDED PRECEDING */
160921	314, /* (321) frame_bound_e ::= frame_bound */
160922	314, /* (322) frame_bound_e ::= UNBOUNDED FOLLOWING */
160923	312, /* (323) frame_bound ::= expr PRECEDING\|FOLLOWING */
160924	312, /* (324) frame_bound ::= CURRENT ROW */
160925	315, /* (325) frame_exclude_opt ::= */
160926	315, /* (326) frame_exclude_opt ::= EXCLUDE frame_exclude */
160927	316, /* (327) frame_exclude ::= NO OTHERS */
160928	316, /* (328) frame_exclude ::= CURRENT ROW */
160929	316, /* (329) frame_exclude ::= GROUP\|TIES */
160930	249, /* (330) window_clause ::= WINDOW windowdefn_list */
160931	271, /* (331) filter_over ::= filter_clause over_clause */
160932	271, /* (332) filter_over ::= over_clause */
160933	271, /* (333) filter_over ::= filter_clause */
160934	310, /* (334) over_clause ::= OVER LP window RP */
160935	310, /* (335) over_clause ::= OVER nm */
160936	309, /* (336) filter_clause ::= FILTER LP WHERE expr RP */
160937	184, /* (337) input ::= cmdlist */
160938	185, /* (338) cmdlist ::= cmdlist ecmd */
160939	185, /* (339) cmdlist ::= ecmd */
160940	186, /* (340) ecmd ::= SEMI */
160941	186, /* (341) ecmd ::= cmdx SEMI */
160942	186, /* (342) ecmd ::= explain cmdx SEMI */
160943	191, /* (343) trans_opt ::= */
160944	191, /* (344) trans_opt ::= TRANSACTION */
160945	191, /* (345) trans_opt ::= TRANSACTION nm */
160946	193, /* (346) savepoint_opt ::= SAVEPOINT */
160947	193, /* (347) savepoint_opt ::= */
160948	189, /* (348) cmd ::= create_table create_table_args */
160949	200, /* (349) columnlist ::= columnlist COMMA columnname carglist */
160950	200, /* (350) columnlist ::= columnname carglist */
160951	192, /* (351) nm ::= ID\|INDEXED */
160952	192, /* (352) nm ::= STRING */
160953	192, /* (353) nm ::= JOIN_KW */
160954	206, /* (354) typetoken ::= typename */
160955	207, /* (355) typename ::= ID\|STRING */
160956	208, /* (356) signed ::= plus_num */
160957	208, /* (357) signed ::= minus_num */
160958	205, /* (358) carglist ::= carglist ccons */
160959	205, /* (359) carglist ::= */
160960	213, /* (360) ccons ::= NULL onconf */
160961	213, /* (361) ccons ::= GENERATED ALWAYS AS generated */
160962	213, /* (362) ccons ::= AS generated */
160963	201, /* (363) conslist_opt ::= COMMA conslist */
160964	226, /* (364) conslist ::= conslist tconscomma tcons */
160965	226, /* (365) conslist ::= tcons */
160966	227, /* (366) tconscomma ::= */
160967	231, /* (367) defer_subclause_opt ::= defer_subclause */
160968	233, /* (368) resolvetype ::= raisetype */
160969	237, /* (369) selectnowith ::= oneselect */
160970	238, /* (370) oneselect ::= values */
160971	252, /* (371) sclp ::= selcollist COMMA */
160972	253, /* (372) as ::= ID\|STRING */
160973	270, /* (373) returning ::= */
160974	215, /* (374) expr ::= term */
160975	272, /* (375) likeop ::= LIKE_KW\|MATCH */
160976	260, /* (376) exprlist ::= nexprlist */
160977	282, /* (377) nmnum ::= plus_num */
160978	282, /* (378) nmnum ::= nm */
160979	282, /* (379) nmnum ::= ON */
160980	282, /* (380) nmnum ::= DELETE */
160981	282, /* (381) nmnum ::= DEFAULT */
160982	209, /* (382) plus_num ::= INTEGER\|FLOAT */
160983	287, /* (383) foreach_clause ::= */
160984	287, /* (384) foreach_clause ::= FOR EACH ROW */
160985	290, /* (385) trnm ::= nm */
160986	291, /* (386) tridxby ::= */
160987	292, /* (387) database_kw_opt ::= DATABASE */
160988	292, /* (388) database_kw_opt ::= */
160989	295, /* (389) kwcolumn_opt ::= */
160990	295, /* (390) kwcolumn_opt ::= COLUMNKW */
160991	297, /* (391) vtabarglist ::= vtabarg */
160992	297, /* (392) vtabarglist ::= vtabarglist COMMA vtabarg */
160993	298, /* (393) vtabarg ::= vtabarg vtabargtoken */
160994	301, /* (394) anylist ::= */
160995	301, /* (395) anylist ::= anylist LP anylist RP */
160996	301, /* (396) anylist ::= anylist ANY */
160997	264, /* (397) with ::= */
160998	};
160999
161000	/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
161001	** of symbols on the right-hand side of that rule. */
161002	static const signed char yyRuleInfoNRhs[] = {
	@@ -161283,20 +161447,20 @@
161447	break;
161448	case 2: /* cmdx ::= cmd */
161449	{ sqlite3FinishCoding(pParse); }
161450	break;
161451	case 3: /* cmd ::= BEGIN transtype trans_opt */
161452	{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy376);}
161453	break;
161454	case 4: /* transtype ::= */
161455	{yymsp[1].minor.yy376 = TK_DEFERRED;}
161456	break;
161457	case 5: /* transtype ::= DEFERRED */
161458	case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
161459	case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
161460	case 318: /* range_or_rows ::= RANGE\|ROWS\|GROUPS */ yytestcase(yyruleno==318);
161461	{yymsp[0].minor.yy376 = yymsp[0].major; /A-overwrites-X/}
161462	break;
161463	case 8: /* cmd ::= COMMIT\|END trans_opt */
161464	case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
161465	{sqlite3EndTransaction(pParse,yymsp[-1].major);}
161466	break;
	@@ -161315,11 +161479,11 @@
161479	sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
161480	}
161481	break;
161482	case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
161483	{
161484	sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy376,0,0,yymsp[-2].minor.yy376);
161485	}
161486	break;
161487	case 14: /* createkw ::= CREATE */
161488	{disableLookaside(pParse);}
161489	break;
	@@ -161330,35 +161494,35 @@
161494	case 60: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==60);
161495	case 70: /* defer_subclause_opt ::= */ yytestcase(yyruleno==70);
161496	case 79: /* ifexists ::= */ yytestcase(yyruleno==79);
161497	case 96: /* distinct ::= */ yytestcase(yyruleno==96);
161498	case 239: /* collate ::= */ yytestcase(yyruleno==239);
161499	{yymsp[1].minor.yy376 = 0;}
161500	break;
161501	case 16: /* ifnotexists ::= IF NOT EXISTS */
161502	{yymsp[-2].minor.yy376 = 1;}
161503	break;
161504	case 17: /* temp ::= TEMP */
161505	{yymsp[0].minor.yy376 = pParse->db->init.busy==0;}
161506	break;
161507	case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_options */
161508	{
161509	sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy376,0);
161510	}
161511	break;
161512	case 20: /* create_table_args ::= AS select */
161513	{
161514	sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy81);
161515	sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy81);
161516	}
161517	break;
161518	case 22: /* table_options ::= WITHOUT nm */
161519	{
161520	if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
161521	yymsp[-1].minor.yy376 = TF_WithoutRowid \| TF_NoVisibleRowid;
161522	}else{
161523	yymsp[-1].minor.yy376 = 0;
161524	sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
161525	}
161526	}
161527	break;
161528	case 23: /* columnname ::= nm typetoken */
	@@ -161383,11 +161547,11 @@
161547	{yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
161548	break;
161549	case 28: /* scanpt ::= */
161550	{
161551	assert( yyLookahead!=YYNOCODE );
161552	yymsp[1].minor.yy504 = yyLookaheadToken.z;
161553	}
161554	break;
161555	case 29: /* scantok ::= */
161556	{
161557	assert( yyLookahead!=YYNOCODE );
	@@ -161397,21 +161561,21 @@
161561	case 30: /* ccons ::= CONSTRAINT nm */
161562	case 65: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==65);
161563	{pParse->constraintName = yymsp[0].minor.yy0;}
161564	break;
161565	case 31: /* ccons ::= DEFAULT scantok term */
161566	{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy404,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
161567	break;
161568	case 32: /* ccons ::= DEFAULT LP expr RP */
161569	{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy404,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
161570	break;
161571	case 33: /* ccons ::= DEFAULT PLUS scantok term */
161572	{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy404,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
161573	break;
161574	case 34: /* ccons ::= DEFAULT MINUS scantok term */
161575	{
161576	Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy404, 0);
161577	sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
161578	}
161579	break;
161580	case 35: /* ccons ::= DEFAULT scantok ID\|INDEXED */
161581	{
	@@ -161422,259 +161586,259 @@
161586	}
161587	sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
161588	}
161589	break;
161590	case 36: /* ccons ::= NOT NULL onconf */
161591	{sqlite3AddNotNull(pParse, yymsp[0].minor.yy376);}
161592	break;
161593	case 37: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
161594	{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy376,yymsp[0].minor.yy376,yymsp[-2].minor.yy376);}
161595	break;
161596	case 38: /* ccons ::= UNIQUE onconf */
161597	{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy376,0,0,0,0,
161598	SQLITE_IDXTYPE_UNIQUE);}
161599	break;
161600	case 39: /* ccons ::= CHECK LP expr RP */
161601	{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy404,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
161602	break;
161603	case 40: /* ccons ::= REFERENCES nm eidlist_opt refargs */
161604	{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy70,yymsp[0].minor.yy376);}
161605	break;
161606	case 41: /* ccons ::= defer_subclause */
161607	{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy376);}
161608	break;
161609	case 42: /* ccons ::= COLLATE ID\|STRING */
161610	{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
161611	break;
161612	case 43: /* generated ::= LP expr RP */
161613	{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy404,0);}
161614	break;
161615	case 44: /* generated ::= LP expr RP ID */
161616	{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy404,&yymsp[0].minor.yy0);}
161617	break;
161618	case 46: /* autoinc ::= AUTOINCR */
161619	{yymsp[0].minor.yy376 = 1;}
161620	break;
161621	case 47: /* refargs ::= */
161622	{ yymsp[1].minor.yy376 = OE_None0x0101; / EV: R-19803-45884 */}
161623	break;
161624	case 48: /* refargs ::= refargs refarg */
161625	{ yymsp[-1].minor.yy376 = (yymsp[-1].minor.yy376 & ~yymsp[0].minor.yy139.mask) \| yymsp[0].minor.yy139.value; }
161626	break;
161627	case 49: /* refarg ::= MATCH nm */
161628	{ yymsp[-1].minor.yy139.value = 0; yymsp[-1].minor.yy139.mask = 0x000000; }
161629	break;
161630	case 50: /* refarg ::= ON INSERT refact */
161631	{ yymsp[-2].minor.yy139.value = 0; yymsp[-2].minor.yy139.mask = 0x000000; }
161632	break;
161633	case 51: /* refarg ::= ON DELETE refact */
161634	{ yymsp[-2].minor.yy139.value = yymsp[0].minor.yy376; yymsp[-2].minor.yy139.mask = 0x0000ff; }
161635	break;
161636	case 52: /* refarg ::= ON UPDATE refact */
161637	{ yymsp[-2].minor.yy139.value = yymsp[0].minor.yy376<<8; yymsp[-2].minor.yy139.mask = 0x00ff00; }
161638	break;
161639	case 53: /* refact ::= SET NULL */
161640	{ yymsp[-1].minor.yy376 = OE_SetNull; /* EV: R-33326-45252 */}
161641	break;
161642	case 54: /* refact ::= SET DEFAULT */
161643	{ yymsp[-1].minor.yy376 = OE_SetDflt; /* EV: R-33326-45252 */}
161644	break;
161645	case 55: /* refact ::= CASCADE */
161646	{ yymsp[0].minor.yy376 = OE_Cascade; /* EV: R-33326-45252 */}
161647	break;
161648	case 56: /* refact ::= RESTRICT */
161649	{ yymsp[0].minor.yy376 = OE_Restrict; /* EV: R-33326-45252 */}
161650	break;
161651	case 57: /* refact ::= NO ACTION */
161652	{ yymsp[-1].minor.yy376 = OE_None; /* EV: R-33326-45252 */}
161653	break;
161654	case 58: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
161655	{yymsp[-2].minor.yy376 = 0;}
161656	break;
161657	case 59: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
161658	case 74: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==74);
161659	case 169: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==169);
161660	{yymsp[-1].minor.yy376 = yymsp[0].minor.yy376;}
161661	break;
161662	case 61: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
161663	case 78: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==78);
161664	case 211: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==211);
161665	case 214: /* in_op ::= NOT IN */ yytestcase(yyruleno==214);
161666	case 240: /* collate ::= COLLATE ID\|STRING */ yytestcase(yyruleno==240);
161667	{yymsp[-1].minor.yy376 = 1;}
161668	break;
161669	case 62: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
161670	{yymsp[-1].minor.yy376 = 0;}
161671	break;
161672	case 64: /* tconscomma ::= COMMA */
161673	{pParse->constraintName.n = 0;}
161674	break;
161675	case 66: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
161676	{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy70,yymsp[0].minor.yy376,yymsp[-2].minor.yy376,0);}
161677	break;
161678	case 67: /* tcons ::= UNIQUE LP sortlist RP onconf */
161679	{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy70,yymsp[0].minor.yy376,0,0,0,0,
161680	SQLITE_IDXTYPE_UNIQUE);}
161681	break;
161682	case 68: /* tcons ::= CHECK LP expr RP onconf */
161683	{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy404,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
161684	break;
161685	case 69: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
161686	{
161687	sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy70, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy70, yymsp[-1].minor.yy376);
161688	sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy376);
161689	}
161690	break;
161691	case 71: /* onconf ::= */
161692	case 73: /* orconf ::= */ yytestcase(yyruleno==73);
161693	{yymsp[1].minor.yy376 = OE_Default;}
161694	break;
161695	case 72: /* onconf ::= ON CONFLICT resolvetype */
161696	{yymsp[-2].minor.yy376 = yymsp[0].minor.yy376;}
161697	break;
161698	case 75: /* resolvetype ::= IGNORE */
161699	{yymsp[0].minor.yy376 = OE_Ignore;}
161700	break;
161701	case 76: /* resolvetype ::= REPLACE */
161702	case 170: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==170);
161703	{yymsp[0].minor.yy376 = OE_Replace;}
161704	break;
161705	case 77: /* cmd ::= DROP TABLE ifexists fullname */
161706	{
161707	sqlite3DropTable(pParse, yymsp[0].minor.yy153, 0, yymsp[-1].minor.yy376);
161708	}
161709	break;
161710	case 80: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
161711	{
161712	sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy70, yymsp[0].minor.yy81, yymsp[-7].minor.yy376, yymsp[-5].minor.yy376);
161713	}
161714	break;
161715	case 81: /* cmd ::= DROP VIEW ifexists fullname */
161716	{
161717	sqlite3DropTable(pParse, yymsp[0].minor.yy153, 1, yymsp[-1].minor.yy376);
161718	}
161719	break;
161720	case 82: /* cmd ::= select */
161721	{
161722	SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
161723	sqlite3Select(pParse, yymsp[0].minor.yy81, &dest);
161724	sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy81);
161725	}
161726	break;
161727	case 83: /* select ::= WITH wqlist selectnowith */
161728	{yymsp[-2].minor.yy81 = attachWithToSelect(pParse,yymsp[0].minor.yy81,yymsp[-1].minor.yy103);}
161729	break;
161730	case 84: /* select ::= WITH RECURSIVE wqlist selectnowith */
161731	{yymsp[-3].minor.yy81 = attachWithToSelect(pParse,yymsp[0].minor.yy81,yymsp[-1].minor.yy103);}
161732	break;
161733	case 85: /* select ::= selectnowith */
161734	{
161735	Select *p = yymsp[0].minor.yy81;
161736	if( p ){
161737	parserDoubleLinkSelect(pParse, p);
161738	}
161739	yymsp[0].minor.yy81 = p; /A-overwrites-X/
161740	}
161741	break;
161742	case 86: /* selectnowith ::= selectnowith multiselect_op oneselect */
161743	{
161744	Select *pRhs = yymsp[0].minor.yy81;
161745	Select *pLhs = yymsp[-2].minor.yy81;
161746	if( pRhs && pRhs->pPrior ){
161747	SrcList *pFrom;
161748	Token x;
161749	x.n = 0;
161750	parserDoubleLinkSelect(pParse, pRhs);
161751	pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);
161752	pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
161753	}
161754	if( pRhs ){
161755	pRhs->op = (u8)yymsp[-1].minor.yy376;
161756	pRhs->pPrior = pLhs;
161757	if( ALWAYS(pLhs) ) pLhs->selFlags &= ~SF_MultiValue;
161758	pRhs->selFlags &= ~SF_MultiValue;
161759	if( yymsp[-1].minor.yy376!=TK_ALL ) pParse->hasCompound = 1;
161760	}else{
161761	sqlite3SelectDelete(pParse->db, pLhs);
161762	}
161763	yymsp[-2].minor.yy81 = pRhs;
161764	}
161765	break;
161766	case 87: /* multiselect_op ::= UNION */
161767	case 89: /* multiselect_op ::= EXCEPT\|INTERSECT */ yytestcase(yyruleno==89);
161768	{yymsp[0].minor.yy376 = yymsp[0].major; /A-overwrites-OP/}
161769	break;
161770	case 88: /* multiselect_op ::= UNION ALL */
161771	{yymsp[-1].minor.yy376 = TK_ALL;}
161772	break;
161773	case 90: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
161774	{
161775	yymsp[-8].minor.yy81 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy70,yymsp[-5].minor.yy153,yymsp[-4].minor.yy404,yymsp[-3].minor.yy70,yymsp[-2].minor.yy404,yymsp[-1].minor.yy70,yymsp[-7].minor.yy376,yymsp[0].minor.yy404);
161776	}
161777	break;
161778	case 91: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
161779	{
161780	yymsp[-9].minor.yy81 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy70,yymsp[-6].minor.yy153,yymsp[-5].minor.yy404,yymsp[-4].minor.yy70,yymsp[-3].minor.yy404,yymsp[-1].minor.yy70,yymsp[-8].minor.yy376,yymsp[0].minor.yy404);
161781	if( yymsp[-9].minor.yy81 ){
161782	yymsp[-9].minor.yy81->pWinDefn = yymsp[-2].minor.yy49;
161783	}else{
161784	sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy49);
161785	}
161786	}
161787	break;
161788	case 92: /* values ::= VALUES LP nexprlist RP */
161789	{
161790	yymsp[-3].minor.yy81 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy70,0,0,0,0,0,SF_Values,0);
161791	}
161792	break;
161793	case 93: /* values ::= values COMMA LP nexprlist RP */
161794	{
161795	Select pRight, pLeft = yymsp[-4].minor.yy81;
161796	pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy70,0,0,0,0,0,SF_Values\|SF_MultiValue,0);
161797	if( ALWAYS(pLeft) ) pLeft->selFlags &= ~SF_MultiValue;
161798	if( pRight ){
161799	pRight->op = TK_ALL;
161800	pRight->pPrior = pLeft;
161801	yymsp[-4].minor.yy81 = pRight;
161802	}else{
161803	yymsp[-4].minor.yy81 = pLeft;
161804	}
161805	}
161806	break;
161807	case 94: /* distinct ::= DISTINCT */
161808	{yymsp[0].minor.yy376 = SF_Distinct;}
161809	break;
161810	case 95: /* distinct ::= ALL */
161811	{yymsp[0].minor.yy376 = SF_All;}
161812	break;
161813	case 97: /* sclp ::= */
161814	case 130: /* orderby_opt ::= */ yytestcase(yyruleno==130);
161815	case 140: /* groupby_opt ::= */ yytestcase(yyruleno==140);
161816	case 227: /* exprlist ::= */ yytestcase(yyruleno==227);
161817	case 230: /* paren_exprlist ::= */ yytestcase(yyruleno==230);
161818	case 235: /* eidlist_opt ::= */ yytestcase(yyruleno==235);
161819	{yymsp[1].minor.yy70 = 0;}
161820	break;
161821	case 98: /* selcollist ::= sclp scanpt expr scanpt as */
161822	{
161823	yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy70, yymsp[-2].minor.yy404);
161824	if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy70, &yymsp[0].minor.yy0, 1);
161825	sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy70,yymsp[-3].minor.yy504,yymsp[-1].minor.yy504);
161826	}
161827	break;
161828	case 99: /* selcollist ::= sclp scanpt STAR */
161829	{
161830	Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
161831	yymsp[-2].minor.yy70 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy70, p);
161832	}
161833	break;
161834	case 100: /* selcollist ::= sclp scanpt nm DOT STAR */
161835	{
161836	Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
161837	Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
161838	Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
161839	yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy70, pDot);
161840	}
161841	break;
161842	case 101: /* as ::= AS nm */
161843	case 112: /* dbnm ::= DOT nm */ yytestcase(yyruleno==112);
161844	case 251: /* plus_num ::= PLUS INTEGER\|FLOAT */ yytestcase(yyruleno==251);
	@@ -161681,49 +161845,49 @@
161845	case 252: /* minus_num ::= MINUS INTEGER\|FLOAT */ yytestcase(yyruleno==252);
161846	{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
161847	break;
161848	case 103: /* from ::= */
161849	case 106: /* stl_prefix ::= */ yytestcase(yyruleno==106);
161850	{yymsp[1].minor.yy153 = 0;}
161851	break;
161852	case 104: /* from ::= FROM seltablist */
161853	{
161854	yymsp[-1].minor.yy153 = yymsp[0].minor.yy153;
161855	sqlite3SrcListShiftJoinType(yymsp[-1].minor.yy153);
161856	}
161857	break;
161858	case 105: /* stl_prefix ::= seltablist joinop */
161859	{
161860	if( ALWAYS(yymsp[-1].minor.yy153 && yymsp[-1].minor.yy153->nSrc>0) ) yymsp[-1].minor.yy153->a[yymsp[-1].minor.yy153->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy376;
161861	}
161862	break;
161863	case 107: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
161864	{
161865	yymsp[-6].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy153,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
161866	sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy153, &yymsp[-2].minor.yy0);
161867	}
161868	break;
161869	case 108: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_opt using_opt */
161870	{
161871	yymsp[-8].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-8].minor.yy153,&yymsp[-7].minor.yy0,&yymsp[-6].minor.yy0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
161872	sqlite3SrcListFuncArgs(pParse, yymsp[-8].minor.yy153, yymsp[-4].minor.yy70);
161873	}
161874	break;
161875	case 109: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
161876	{
161877	yymsp[-6].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy153,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy81,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
161878	}
161879	break;
161880	case 110: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
161881	{
161882	if( yymsp[-6].minor.yy153==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy404==0 && yymsp[0].minor.yy436==0 ){
161883	yymsp[-6].minor.yy153 = yymsp[-4].minor.yy153;
161884	}else if( yymsp[-4].minor.yy153->nSrc==1 ){
161885	yymsp[-6].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy153,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
161886	if( yymsp[-6].minor.yy153 ){
161887	SrcItem *pNew = &yymsp[-6].minor.yy153->a[yymsp[-6].minor.yy153->nSrc-1];
161888	SrcItem *pOld = yymsp[-4].minor.yy153->a;
161889	pNew->zName = pOld->zName;
161890	pNew->zDatabase = pOld->zDatabase;
161891	pNew->pSelect = pOld->pSelect;
161892	if( pOld->fg.isTabFunc ){
161893	pNew->u1.pFuncArg = pOld->u1.pFuncArg;
	@@ -161732,240 +161896,240 @@
161896	pNew->fg.isTabFunc = 1;
161897	}
161898	pOld->zName = pOld->zDatabase = 0;
161899	pOld->pSelect = 0;
161900	}
161901	sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy153);
161902	}else{
161903	Select *pSubquery;
161904	sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy153);
161905	pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy153,0,0,0,0,SF_NestedFrom,0);
161906	yymsp[-6].minor.yy153 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy153,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy404,yymsp[0].minor.yy436);
161907	}
161908	}
161909	break;
161910	case 111: /* dbnm ::= */
161911	case 125: /* indexed_opt ::= */ yytestcase(yyruleno==125);
161912	{yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
161913	break;
161914	case 113: /* fullname ::= nm */
161915	{
161916	yylhsminor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
161917	if( IN_RENAME_OBJECT && yylhsminor.yy153 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy153->a[0].zName, &yymsp[0].minor.yy0);
161918	}
161919	yymsp[0].minor.yy153 = yylhsminor.yy153;
161920	break;
161921	case 114: /* fullname ::= nm DOT nm */
161922	{
161923	yylhsminor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
161924	if( IN_RENAME_OBJECT && yylhsminor.yy153 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy153->a[0].zName, &yymsp[0].minor.yy0);
161925	}
161926	yymsp[-2].minor.yy153 = yylhsminor.yy153;
161927	break;
161928	case 115: /* xfullname ::= nm */
161929	{yymsp[0].minor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /A-overwrites-X/}
161930	break;
161931	case 116: /* xfullname ::= nm DOT nm */
161932	{yymsp[-2].minor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /A-overwrites-X/}
161933	break;
161934	case 117: /* xfullname ::= nm DOT nm AS nm */
161935	{
161936	yymsp[-4].minor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /A-overwrites-X/
161937	if( yymsp[-4].minor.yy153 ) yymsp[-4].minor.yy153->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
161938	}
161939	break;
161940	case 118: /* xfullname ::= nm AS nm */
161941	{
161942	yymsp[-2].minor.yy153 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /A-overwrites-X/
161943	if( yymsp[-2].minor.yy153 ) yymsp[-2].minor.yy153->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
161944	}
161945	break;
161946	case 119: /* joinop ::= COMMA\|JOIN */
161947	{ yymsp[0].minor.yy376 = JT_INNER; }
161948	break;
161949	case 120: /* joinop ::= JOIN_KW JOIN */
161950	{yymsp[-1].minor.yy376 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /X-overwrites-A/}
161951	break;
161952	case 121: /* joinop ::= JOIN_KW nm JOIN */
161953	{yymsp[-2].minor.yy376 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /X-overwrites-A/}
161954	break;
161955	case 122: /* joinop ::= JOIN_KW nm nm JOIN */
161956	{yymsp[-3].minor.yy376 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/X-overwrites-A/}
161957	break;
161958	case 123: /* on_opt ::= ON expr */
161959	case 143: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==143);
161960	case 150: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==150);
161961	case 152: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==152);
161962	case 223: /* case_else ::= ELSE expr */ yytestcase(yyruleno==223);
161963	case 244: /* vinto ::= INTO expr */ yytestcase(yyruleno==244);
161964	{yymsp[-1].minor.yy404 = yymsp[0].minor.yy404;}
161965	break;
161966	case 124: /* on_opt ::= */
161967	case 142: /* having_opt ::= */ yytestcase(yyruleno==142);
161968	case 144: /* limit_opt ::= */ yytestcase(yyruleno==144);
161969	case 149: /* where_opt ::= */ yytestcase(yyruleno==149);
161970	case 151: /* where_opt_ret ::= */ yytestcase(yyruleno==151);
161971	case 224: /* case_else ::= */ yytestcase(yyruleno==224);
161972	case 226: /* case_operand ::= */ yytestcase(yyruleno==226);
161973	case 245: /* vinto ::= */ yytestcase(yyruleno==245);
161974	{yymsp[1].minor.yy404 = 0;}
161975	break;
161976	case 126: /* indexed_opt ::= INDEXED BY nm */
161977	{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
161978	break;
161979	case 127: /* indexed_opt ::= NOT INDEXED */
161980	{yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
161981	break;
161982	case 128: /* using_opt ::= USING LP idlist RP */
161983	{yymsp[-3].minor.yy436 = yymsp[-1].minor.yy436;}
161984	break;
161985	case 129: /* using_opt ::= */
161986	case 171: /* idlist_opt ::= */ yytestcase(yyruleno==171);
161987	{yymsp[1].minor.yy436 = 0;}
161988	break;
161989	case 131: /* orderby_opt ::= ORDER BY sortlist */
161990	case 141: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==141);
161991	{yymsp[-2].minor.yy70 = yymsp[0].minor.yy70;}
161992	break;
161993	case 132: /* sortlist ::= sortlist COMMA expr sortorder nulls */
161994	{
161995	yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy70,yymsp[-2].minor.yy404);
161996	sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy70,yymsp[-1].minor.yy376,yymsp[0].minor.yy376);
161997	}
161998	break;
161999	case 133: /* sortlist ::= expr sortorder nulls */
162000	{
162001	yymsp[-2].minor.yy70 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy404); /A-overwrites-Y/
162002	sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy70,yymsp[-1].minor.yy376,yymsp[0].minor.yy376);
162003	}
162004	break;
162005	case 134: /* sortorder ::= ASC */
162006	{yymsp[0].minor.yy376 = SQLITE_SO_ASC;}
162007	break;
162008	case 135: /* sortorder ::= DESC */
162009	{yymsp[0].minor.yy376 = SQLITE_SO_DESC;}
162010	break;
162011	case 136: /* sortorder ::= */
162012	case 139: /* nulls ::= */ yytestcase(yyruleno==139);
162013	{yymsp[1].minor.yy376 = SQLITE_SO_UNDEFINED;}
162014	break;
162015	case 137: /* nulls ::= NULLS FIRST */
162016	{yymsp[-1].minor.yy376 = SQLITE_SO_ASC;}
162017	break;
162018	case 138: /* nulls ::= NULLS LAST */
162019	{yymsp[-1].minor.yy376 = SQLITE_SO_DESC;}
162020	break;
162021	case 145: /* limit_opt ::= LIMIT expr */
162022	{yymsp[-1].minor.yy404 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy404,0);}
162023	break;
162024	case 146: /* limit_opt ::= LIMIT expr OFFSET expr */
162025	{yymsp[-3].minor.yy404 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy404,yymsp[0].minor.yy404);}
162026	break;
162027	case 147: /* limit_opt ::= LIMIT expr COMMA expr */
162028	{yymsp[-3].minor.yy404 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy404,yymsp[-2].minor.yy404);}
162029	break;
162030	case 148: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
162031	{
162032	sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy153, &yymsp[-1].minor.yy0);
162033	sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy153,yymsp[0].minor.yy404,0,0);
162034	}
162035	break;
162036	case 153: /* where_opt_ret ::= RETURNING selcollist */
162037	{sqlite3AddReturning(pParse,yymsp[0].minor.yy70); yymsp[-1].minor.yy404 = 0;}
162038	break;
162039	case 154: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
162040	{sqlite3AddReturning(pParse,yymsp[0].minor.yy70); yymsp[-3].minor.yy404 = yymsp[-2].minor.yy404;}
162041	break;
162042	case 155: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
162043	{
162044	sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy153, &yymsp[-4].minor.yy0);
162045	sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy70,"set list");
162046	yymsp[-5].minor.yy153 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy153, yymsp[-1].minor.yy153);
162047	sqlite3Update(pParse,yymsp[-5].minor.yy153,yymsp[-2].minor.yy70,yymsp[0].minor.yy404,yymsp[-6].minor.yy376,0,0,0);
162048	}
162049	break;
162050	case 156: /* setlist ::= setlist COMMA nm EQ expr */
162051	{
162052	yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy70, yymsp[0].minor.yy404);
162053	sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy70, &yymsp[-2].minor.yy0, 1);
162054	}
162055	break;
162056	case 157: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
162057	{
162058	yymsp[-6].minor.yy70 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy70, yymsp[-3].minor.yy436, yymsp[0].minor.yy404);
162059	}
162060	break;
162061	case 158: /* setlist ::= nm EQ expr */
162062	{
162063	yylhsminor.yy70 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy404);
162064	sqlite3ExprListSetName(pParse, yylhsminor.yy70, &yymsp[-2].minor.yy0, 1);
162065	}
162066	yymsp[-2].minor.yy70 = yylhsminor.yy70;
162067	break;
162068	case 159: /* setlist ::= LP idlist RP EQ expr */
162069	{
162070	yymsp[-4].minor.yy70 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy436, yymsp[0].minor.yy404);
162071	}
162072	break;
162073	case 160: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
162074	{
162075	sqlite3Insert(pParse, yymsp[-3].minor.yy153, yymsp[-1].minor.yy81, yymsp[-2].minor.yy436, yymsp[-5].minor.yy376, yymsp[0].minor.yy190);
162076	}
162077	break;
162078	case 161: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
162079	{
162080	sqlite3Insert(pParse, yymsp[-4].minor.yy153, 0, yymsp[-3].minor.yy436, yymsp[-6].minor.yy376, 0);
162081	}
162082	break;
162083	case 162: /* upsert ::= */
162084	{ yymsp[1].minor.yy190 = 0; }
162085	break;
162086	case 163: /* upsert ::= RETURNING selcollist */
162087	{ yymsp[-1].minor.yy190 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy70); }
162088	break;
162089	case 164: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
162090	{ yymsp[-11].minor.yy190 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy70,yymsp[-6].minor.yy404,yymsp[-2].minor.yy70,yymsp[-1].minor.yy404,yymsp[0].minor.yy190);}
162091	break;
162092	case 165: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
162093	{ yymsp[-8].minor.yy190 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy70,yymsp[-3].minor.yy404,0,0,yymsp[0].minor.yy190); }
162094	break;
162095	case 166: /* upsert ::= ON CONFLICT DO NOTHING returning */
162096	{ yymsp[-4].minor.yy190 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
162097	break;
162098	case 167: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
162099	{ yymsp[-7].minor.yy190 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy70,yymsp[-1].minor.yy404,0);}
162100	break;
162101	case 168: /* returning ::= RETURNING selcollist */
162102	{sqlite3AddReturning(pParse,yymsp[0].minor.yy70);}
162103	break;
162104	case 172: /* idlist_opt ::= LP idlist RP */
162105	{yymsp[-2].minor.yy436 = yymsp[-1].minor.yy436;}
162106	break;
162107	case 173: /* idlist ::= idlist COMMA nm */
162108	{yymsp[-2].minor.yy436 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy436,&yymsp[0].minor.yy0);}
162109	break;
162110	case 174: /* idlist ::= nm */
162111	{yymsp[0].minor.yy436 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /A-overwrites-Y/}
162112	break;
162113	case 175: /* expr ::= LP expr RP */
162114	{yymsp[-2].minor.yy404 = yymsp[-1].minor.yy404;}
162115	break;
162116	case 176: /* expr ::= ID\|INDEXED */
162117	case 177: /* expr ::= JOIN_KW */ yytestcase(yyruleno==177);
162118	{yymsp[0].minor.yy404=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /A-overwrites-X/}
162119	break;
162120	case 178: /* expr ::= nm DOT nm */
162121	{
162122	Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
162123	Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1);
162124	if( IN_RENAME_OBJECT ){
162125	sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0);
162126	sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0);
162127	}
162128	yylhsminor.yy404 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
162129	}
162130	yymsp[-2].minor.yy404 = yylhsminor.yy404;
162131	break;
162132	case 179: /* expr ::= nm DOT nm DOT nm */
162133	{
162134	Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-4].minor.yy0, 1);
162135	Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
	@@ -161973,322 +162137,322 @@
162137	Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
162138	if( IN_RENAME_OBJECT ){
162139	sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0);
162140	sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0);
162141	}
162142	yylhsminor.yy404 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
162143	}
162144	yymsp[-4].minor.yy404 = yylhsminor.yy404;
162145	break;
162146	case 180: /* term ::= NULL\|FLOAT\|BLOB */
162147	case 181: /* term ::= STRING */ yytestcase(yyruleno==181);
162148	{yymsp[0].minor.yy404=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /A-overwrites-X/}
162149	break;
162150	case 182: /* term ::= INTEGER */
162151	{
162152	yylhsminor.yy404 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
162153	}
162154	yymsp[0].minor.yy404 = yylhsminor.yy404;
162155	break;
162156	case 183: /* expr ::= VARIABLE */
162157	{
162158	if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
162159	u32 n = yymsp[0].minor.yy0.n;
162160	yymsp[0].minor.yy404 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
162161	sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy404, n);
162162	}else{
162163	/* When doing a nested parse, one can include terms in an expression
162164	** that look like this: #1 #2 ... These terms refer to registers
162165	** in the virtual machine. #N is the N-th register. */
162166	Token t = yymsp[0].minor.yy0; /A-overwrites-X/
162167	assert( t.n>=2 );
162168	if( pParse->nested==0 ){
162169	sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
162170	yymsp[0].minor.yy404 = 0;
162171	}else{
162172	yymsp[0].minor.yy404 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
162173	if( yymsp[0].minor.yy404 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy404->iTable);
162174	}
162175	}
162176	}
162177	break;
162178	case 184: /* expr ::= expr COLLATE ID\|STRING */
162179	{
162180	yymsp[-2].minor.yy404 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy404, &yymsp[0].minor.yy0, 1);
162181	}
162182	break;
162183	case 185: /* expr ::= CAST LP expr AS typetoken RP */
162184	{
162185	yymsp[-5].minor.yy404 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
162186	sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy404, yymsp[-3].minor.yy404, 0);
162187	}
162188	break;
162189	case 186: /* expr ::= ID\|INDEXED LP distinct exprlist RP */
162190	{
162191	yylhsminor.yy404 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy70, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy376);
162192	}
162193	yymsp[-4].minor.yy404 = yylhsminor.yy404;
162194	break;
162195	case 187: /* expr ::= ID\|INDEXED LP STAR RP */
162196	{
162197	yylhsminor.yy404 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
162198	}
162199	yymsp[-3].minor.yy404 = yylhsminor.yy404;
162200	break;
162201	case 188: /* expr ::= ID\|INDEXED LP distinct exprlist RP filter_over */
162202	{
162203	yylhsminor.yy404 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy70, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy376);
162204	sqlite3WindowAttach(pParse, yylhsminor.yy404, yymsp[0].minor.yy49);
162205	}
162206	yymsp[-5].minor.yy404 = yylhsminor.yy404;
162207	break;
162208	case 189: /* expr ::= ID\|INDEXED LP STAR RP filter_over */
162209	{
162210	yylhsminor.yy404 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
162211	sqlite3WindowAttach(pParse, yylhsminor.yy404, yymsp[0].minor.yy49);
162212	}
162213	yymsp[-4].minor.yy404 = yylhsminor.yy404;
162214	break;
162215	case 190: /* term ::= CTIME_KW */
162216	{
162217	yylhsminor.yy404 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
162218	}
162219	yymsp[0].minor.yy404 = yylhsminor.yy404;
162220	break;
162221	case 191: /* expr ::= LP nexprlist COMMA expr RP */
162222	{
162223	ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy70, yymsp[-1].minor.yy404);
162224	yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
162225	if( yymsp[-4].minor.yy404 ){
162226	yymsp[-4].minor.yy404->x.pList = pList;
162227	if( ALWAYS(pList->nExpr) ){
162228	yymsp[-4].minor.yy404->flags \|= pList->a[0].pExpr->flags & EP_Propagate;
162229	}
162230	}else{
162231	sqlite3ExprListDelete(pParse->db, pList);
162232	}
162233	}
162234	break;
162235	case 192: /* expr ::= expr AND expr */
162236	{yymsp[-2].minor.yy404=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy404,yymsp[0].minor.yy404);}
162237	break;
162238	case 193: /* expr ::= expr OR expr */
162239	case 194: /* expr ::= expr LT\|GT\|GE\|LE expr */ yytestcase(yyruleno==194);
162240	case 195: /* expr ::= expr EQ\|NE expr */ yytestcase(yyruleno==195);
162241	case 196: /* expr ::= expr BITAND\|BITOR\|LSHIFT\|RSHIFT expr */ yytestcase(yyruleno==196);
162242	case 197: /* expr ::= expr PLUS\|MINUS expr */ yytestcase(yyruleno==197);
162243	case 198: /* expr ::= expr STAR\|SLASH\|REM expr */ yytestcase(yyruleno==198);
162244	case 199: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==199);
162245	{yymsp[-2].minor.yy404=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy404,yymsp[0].minor.yy404);}
162246	break;
162247	case 200: /* likeop ::= NOT LIKE_KW\|MATCH */
162248	{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n\|=0x80000000; /yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0/}
162249	break;
162250	case 201: /* expr ::= expr likeop expr */
162251	{
162252	ExprList *pList;
162253	int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
162254	yymsp[-1].minor.yy0.n &= 0x7fffffff;
162255	pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy404);
162256	pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy404);
162257	yymsp[-2].minor.yy404 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
162258	if( bNot ) yymsp[-2].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy404, 0);
162259	if( yymsp[-2].minor.yy404 ) yymsp[-2].minor.yy404->flags \|= EP_InfixFunc;
162260	}
162261	break;
162262	case 202: /* expr ::= expr likeop expr ESCAPE expr */
162263	{
162264	ExprList *pList;
162265	int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
162266	yymsp[-3].minor.yy0.n &= 0x7fffffff;
162267	pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy404);
162268	pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy404);
162269	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy404);
162270	yymsp[-4].minor.yy404 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
162271	if( bNot ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162272	if( yymsp[-4].minor.yy404 ) yymsp[-4].minor.yy404->flags \|= EP_InfixFunc;
162273	}
162274	break;
162275	case 203: /* expr ::= expr ISNULL\|NOTNULL */
162276	{yymsp[-1].minor.yy404 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy404,0);}
162277	break;
162278	case 204: /* expr ::= expr NOT NULL */
162279	{yymsp[-2].minor.yy404 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy404,0);}
162280	break;
162281	case 205: /* expr ::= expr IS expr */
162282	{
162283	yymsp[-2].minor.yy404 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy404,yymsp[0].minor.yy404);
162284	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy404, yymsp[-2].minor.yy404, TK_ISNULL);
162285	}
162286	break;
162287	case 206: /* expr ::= expr IS NOT expr */
162288	{
162289	yymsp[-3].minor.yy404 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy404,yymsp[0].minor.yy404);
162290	binaryToUnaryIfNull(pParse, yymsp[0].minor.yy404, yymsp[-3].minor.yy404, TK_NOTNULL);
162291	}
162292	break;
162293	case 207: /* expr ::= NOT expr */
162294	case 208: /* expr ::= BITNOT expr */ yytestcase(yyruleno==208);
162295	{yymsp[-1].minor.yy404 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy404, 0);/A-overwrites-B/}
162296	break;
162297	case 209: /* expr ::= PLUS\|MINUS expr */
162298	{
162299	yymsp[-1].minor.yy404 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy404, 0);
162300	/A-overwrites-B/
162301	}
162302	break;
162303	case 210: /* between_op ::= BETWEEN */
162304	case 213: /* in_op ::= IN */ yytestcase(yyruleno==213);
162305	{yymsp[0].minor.yy376 = 0;}
162306	break;
162307	case 212: /* expr ::= expr between_op expr AND expr */
162308	{
162309	ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy404);
162310	pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy404);
162311	yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy404, 0);
162312	if( yymsp[-4].minor.yy404 ){
162313	yymsp[-4].minor.yy404->x.pList = pList;
162314	}else{
162315	sqlite3ExprListDelete(pParse->db, pList);
162316	}
162317	if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162318	}
162319	break;
162320	case 215: /* expr ::= expr in_op LP exprlist RP */
162321	{
162322	if( yymsp[-1].minor.yy70==0 ){
162323	/* Expressions of the form
162324	**
162325	** expr1 IN ()
162326	** expr1 NOT IN ()
162327	**
162328	** simplify to constants 0 (false) and 1 (true), respectively,
162329	** regardless of the value of expr1.
162330	*/
162331	sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy404);
162332	yymsp[-4].minor.yy404 = sqlite3Expr(pParse->db, TK_INTEGER, yymsp[-3].minor.yy376 ? "1" : "0");
162333	}else if( yymsp[-1].minor.yy70->nExpr==1 && sqlite3ExprIsConstant(yymsp[-1].minor.yy70->a[0].pExpr) ){
162334	Expr *pRHS = yymsp[-1].minor.yy70->a[0].pExpr;
162335	yymsp[-1].minor.yy70->a[0].pExpr = 0;
162336	sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy70);
162337	pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
162338	yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy404, pRHS);
162339	if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162340	}else{
162341	yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy404, 0);
162342	if( yymsp[-4].minor.yy404 ){
162343	yymsp[-4].minor.yy404->x.pList = yymsp[-1].minor.yy70;
162344	sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy404);
162345	}else{
162346	sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy70);
162347	}
162348	if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162349	}
162350	}
162351	break;
162352	case 216: /* expr ::= LP select RP */
162353	{
162354	yymsp[-2].minor.yy404 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
162355	sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy404, yymsp[-1].minor.yy81);
162356	}
162357	break;
162358	case 217: /* expr ::= expr in_op LP select RP */
162359	{
162360	yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy404, 0);
162361	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy404, yymsp[-1].minor.yy81);
162362	if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162363	}
162364	break;
162365	case 218: /* expr ::= expr in_op nm dbnm paren_exprlist */
162366	{
162367	SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
162368	Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
162369	if( yymsp[0].minor.yy70 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy70);
162370	yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy404, 0);
162371	sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy404, pSelect);
162372	if( yymsp[-3].minor.yy376 ) yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy404, 0);
162373	}
162374	break;
162375	case 219: /* expr ::= EXISTS LP select RP */
162376	{
162377	Expr *p;
162378	p = yymsp[-3].minor.yy404 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
162379	sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy81);
162380	}
162381	break;
162382	case 220: /* expr ::= CASE case_operand case_exprlist case_else END */
162383	{
162384	yymsp[-4].minor.yy404 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy404, 0);
162385	if( yymsp[-4].minor.yy404 ){
162386	yymsp[-4].minor.yy404->x.pList = yymsp[-1].minor.yy404 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy70,yymsp[-1].minor.yy404) : yymsp[-2].minor.yy70;
162387	sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy404);
162388	}else{
162389	sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy70);
162390	sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy404);
162391	}
162392	}
162393	break;
162394	case 221: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
162395	{
162396	yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy70, yymsp[-2].minor.yy404);
162397	yymsp[-4].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy70, yymsp[0].minor.yy404);
162398	}
162399	break;
162400	case 222: /* case_exprlist ::= WHEN expr THEN expr */
162401	{
162402	yymsp[-3].minor.yy70 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy404);
162403	yymsp[-3].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy70, yymsp[0].minor.yy404);
162404	}
162405	break;
162406	case 225: /* case_operand ::= expr */
162407	{yymsp[0].minor.yy404 = yymsp[0].minor.yy404; /A-overwrites-X/}
162408	break;
162409	case 228: /* nexprlist ::= nexprlist COMMA expr */
162410	{yymsp[-2].minor.yy70 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy70,yymsp[0].minor.yy404);}
162411	break;
162412	case 229: /* nexprlist ::= expr */
162413	{yymsp[0].minor.yy70 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy404); /A-overwrites-Y/}
162414	break;
162415	case 231: /* paren_exprlist ::= LP exprlist RP */
162416	case 236: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==236);
162417	{yymsp[-2].minor.yy70 = yymsp[-1].minor.yy70;}
162418	break;
162419	case 232: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
162420	{
162421	sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
162422	sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy70, yymsp[-10].minor.yy376,
162423	&yymsp[-11].minor.yy0, yymsp[0].minor.yy404, SQLITE_SO_ASC, yymsp[-8].minor.yy376, SQLITE_IDXTYPE_APPDEF);
162424	if( IN_RENAME_OBJECT && pParse->pNewIndex ){
162425	sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
162426	}
162427	}
162428	break;
162429	case 233: /* uniqueflag ::= UNIQUE */
162430	case 275: /* raisetype ::= ABORT */ yytestcase(yyruleno==275);
162431	{yymsp[0].minor.yy376 = OE_Abort;}
162432	break;
162433	case 234: /* uniqueflag ::= */
162434	{yymsp[1].minor.yy376 = OE_None;}
162435	break;
162436	case 237: /* eidlist ::= eidlist COMMA nm collate sortorder */
162437	{
162438	yymsp[-4].minor.yy70 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy70, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy376, yymsp[0].minor.yy376);
162439	}
162440	break;
162441	case 238: /* eidlist ::= nm collate sortorder */
162442	{
162443	yymsp[-2].minor.yy70 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy376, yymsp[0].minor.yy376); /A-overwrites-Y/
162444	}
162445	break;
162446	case 241: /* cmd ::= DROP INDEX ifexists fullname */
162447	{sqlite3DropIndex(pParse, yymsp[0].minor.yy153, yymsp[-1].minor.yy376);}
162448	break;
162449	case 242: /* cmd ::= VACUUM vinto */
162450	{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy404);}
162451	break;
162452	case 243: /* cmd ::= VACUUM nm vinto */
162453	{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy404);}
162454	break;
162455	case 246: /* cmd ::= PRAGMA nm dbnm */
162456	{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
162457	break;
162458	case 247: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
	@@ -162306,54 +162470,54 @@
162470	case 253: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
162471	{
162472	Token all;
162473	all.z = yymsp[-3].minor.yy0.z;
162474	all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
162475	sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy157, &all);
162476	}
162477	break;
162478	case 254: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
162479	{
162480	sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy376, yymsp[-4].minor.yy262.a, yymsp[-4].minor.yy262.b, yymsp[-2].minor.yy153, yymsp[0].minor.yy404, yymsp[-10].minor.yy376, yymsp[-8].minor.yy376);
162481	yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /A-overwrites-T/
162482	}
162483	break;
162484	case 255: /* trigger_time ::= BEFORE\|AFTER */
162485	{ yymsp[0].minor.yy376 = yymsp[0].major; /A-overwrites-X/ }
162486	break;
162487	case 256: /* trigger_time ::= INSTEAD OF */
162488	{ yymsp[-1].minor.yy376 = TK_INSTEAD;}
162489	break;
162490	case 257: /* trigger_time ::= */
162491	{ yymsp[1].minor.yy376 = TK_BEFORE; }
162492	break;
162493	case 258: /* trigger_event ::= DELETE\|INSERT */
162494	case 259: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==259);
162495	{yymsp[0].minor.yy262.a = yymsp[0].major; /A-overwrites-X/ yymsp[0].minor.yy262.b = 0;}
162496	break;
162497	case 260: /* trigger_event ::= UPDATE OF idlist */
162498	{yymsp[-2].minor.yy262.a = TK_UPDATE; yymsp[-2].minor.yy262.b = yymsp[0].minor.yy436;}
162499	break;
162500	case 261: /* when_clause ::= */
162501	case 280: /* key_opt ::= */ yytestcase(yyruleno==280);
162502	{ yymsp[1].minor.yy404 = 0; }
162503	break;
162504	case 262: /* when_clause ::= WHEN expr */
162505	case 281: /* key_opt ::= KEY expr */ yytestcase(yyruleno==281);
162506	{ yymsp[-1].minor.yy404 = yymsp[0].minor.yy404; }
162507	break;
162508	case 263: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
162509	{
162510	assert( yymsp[-2].minor.yy157!=0 );
162511	yymsp[-2].minor.yy157->pLast->pNext = yymsp[-1].minor.yy157;
162512	yymsp[-2].minor.yy157->pLast = yymsp[-1].minor.yy157;
162513	}
162514	break;
162515	case 264: /* trigger_cmd_list ::= trigger_cmd SEMI */
162516	{
162517	assert( yymsp[-1].minor.yy157!=0 );
162518	yymsp[-1].minor.yy157->pLast = yymsp[-1].minor.yy157;
162519	}
162520	break;
162521	case 265: /* trnm ::= nm DOT nm */
162522	{
162523	yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
	@@ -162375,62 +162539,62 @@
162539	"the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
162540	"within triggers");
162541	}
162542	break;
162543	case 268: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
162544	{yylhsminor.yy157 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy153, yymsp[-3].minor.yy70, yymsp[-1].minor.yy404, yymsp[-7].minor.yy376, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy504);}
162545	yymsp[-8].minor.yy157 = yylhsminor.yy157;
162546	break;
162547	case 269: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
162548	{
162549	yylhsminor.yy157 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy436,yymsp[-2].minor.yy81,yymsp[-6].minor.yy376,yymsp[-1].minor.yy190,yymsp[-7].minor.yy504,yymsp[0].minor.yy504);/yylhsminor.yy157-overwrites-yymsp[-6].minor.yy376/
162550	}
162551	yymsp[-7].minor.yy157 = yylhsminor.yy157;
162552	break;
162553	case 270: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
162554	{yylhsminor.yy157 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy404, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy504);}
162555	yymsp[-5].minor.yy157 = yylhsminor.yy157;
162556	break;
162557	case 271: /* trigger_cmd ::= scanpt select scanpt */
162558	{yylhsminor.yy157 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy81, yymsp[-2].minor.yy504, yymsp[0].minor.yy504); /yylhsminor.yy157-overwrites-yymsp[-1].minor.yy81/}
162559	yymsp[-2].minor.yy157 = yylhsminor.yy157;
162560	break;
162561	case 272: /* expr ::= RAISE LP IGNORE RP */
162562	{
162563	yymsp[-3].minor.yy404 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
162564	if( yymsp[-3].minor.yy404 ){
162565	yymsp[-3].minor.yy404->affExpr = OE_Ignore;
162566	}
162567	}
162568	break;
162569	case 273: /* expr ::= RAISE LP raisetype COMMA nm RP */
162570	{
162571	yymsp[-5].minor.yy404 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
162572	if( yymsp[-5].minor.yy404 ) {
162573	yymsp[-5].minor.yy404->affExpr = (char)yymsp[-3].minor.yy376;
162574	}
162575	}
162576	break;
162577	case 274: /* raisetype ::= ROLLBACK */
162578	{yymsp[0].minor.yy376 = OE_Rollback;}
162579	break;
162580	case 276: /* raisetype ::= FAIL */
162581	{yymsp[0].minor.yy376 = OE_Fail;}
162582	break;
162583	case 277: /* cmd ::= DROP TRIGGER ifexists fullname */
162584	{
162585	sqlite3DropTrigger(pParse,yymsp[0].minor.yy153,yymsp[-1].minor.yy376);
162586	}
162587	break;
162588	case 278: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
162589	{
162590	sqlite3Attach(pParse, yymsp[-3].minor.yy404, yymsp[-1].minor.yy404, yymsp[0].minor.yy404);
162591	}
162592	break;
162593	case 279: /* cmd ::= DETACH database_kw_opt expr */
162594	{
162595	sqlite3Detach(pParse, yymsp[0].minor.yy404);
162596	}
162597	break;
162598	case 282: /* cmd ::= REINDEX */
162599	{sqlite3Reindex(pParse, 0, 0);}
162600	break;
	@@ -162443,11 +162607,11 @@
162607	case 285: /* cmd ::= ANALYZE nm dbnm */
162608	{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
162609	break;
162610	case 286: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
162611	{
162612	sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy153,&yymsp[0].minor.yy0);
162613	}
162614	break;
162615	case 287: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
162616	{
162617	yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
	@@ -162454,22 +162618,22 @@
162618	sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
162619	}
162620	break;
162621	case 288: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
162622	{
162623	sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy153, &yymsp[0].minor.yy0);
162624	}
162625	break;
162626	case 289: /* add_column_fullname ::= fullname */
162627	{
162628	disableLookaside(pParse);
162629	sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy153);
162630	}
162631	break;
162632	case 290: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
162633	{
162634	sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy153, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
162635	}
162636	break;
162637	case 291: /* cmd ::= create_vtab */
162638	{sqlite3VtabFinishParse(pParse,0);}
162639	break;
	@@ -162476,11 +162640,11 @@
162640	case 292: /* cmd ::= create_vtab LP vtabarglist RP */
162641	{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
162642	break;
162643	case 293: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
162644	{
162645	sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy376);
162646	}
162647	break;
162648	case 294: /* vtabarg ::= */
162649	{sqlite3VtabArgInit(pParse);}
162650	break;
	@@ -162489,180 +162653,180 @@
162653	case 297: /* lp ::= LP */ yytestcase(yyruleno==297);
162654	{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
162655	break;
162656	case 298: /* with ::= WITH wqlist */
162657	case 299: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==299);
162658	{ sqlite3WithPush(pParse, yymsp[0].minor.yy103, 1); }
162659	break;
162660	case 300: /* wqas ::= AS */
162661	{yymsp[0].minor.yy552 = M10d_Any;}
162662	break;
162663	case 301: /* wqas ::= AS MATERIALIZED */
162664	{yymsp[-1].minor.yy552 = M10d_Yes;}
162665	break;
162666	case 302: /* wqas ::= AS NOT MATERIALIZED */
162667	{yymsp[-2].minor.yy552 = M10d_No;}
162668	break;
162669	case 303: /* wqitem ::= nm eidlist_opt wqas LP select RP */
162670	{
162671	yymsp[-5].minor.yy329 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy70, yymsp[-1].minor.yy81, yymsp[-3].minor.yy552); /A-overwrites-X/
162672	}
162673	break;
162674	case 304: /* wqlist ::= wqitem */
162675	{
162676	yymsp[0].minor.yy103 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy329); /A-overwrites-X/
162677	}
162678	break;
162679	case 305: /* wqlist ::= wqlist COMMA wqitem */
162680	{
162681	yymsp[-2].minor.yy103 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy103, yymsp[0].minor.yy329);
162682	}
162683	break;
162684	case 306: /* windowdefn_list ::= windowdefn */
162685	{ yylhsminor.yy49 = yymsp[0].minor.yy49; }
162686	yymsp[0].minor.yy49 = yylhsminor.yy49;
162687	break;
162688	case 307: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
162689	{
162690	assert( yymsp[0].minor.yy49!=0 );
162691	sqlite3WindowChain(pParse, yymsp[0].minor.yy49, yymsp[-2].minor.yy49);
162692	yymsp[0].minor.yy49->pNextWin = yymsp[-2].minor.yy49;
162693	yylhsminor.yy49 = yymsp[0].minor.yy49;
162694	}
162695	yymsp[-2].minor.yy49 = yylhsminor.yy49;
162696	break;
162697	case 308: /* windowdefn ::= nm AS LP window RP */
162698	{
162699	if( ALWAYS(yymsp[-1].minor.yy49) ){
162700	yymsp[-1].minor.yy49->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
162701	}
162702	yylhsminor.yy49 = yymsp[-1].minor.yy49;
162703	}
162704	yymsp[-4].minor.yy49 = yylhsminor.yy49;
162705	break;
162706	case 309: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
162707	{
162708	yymsp[-4].minor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, yymsp[-2].minor.yy70, yymsp[-1].minor.yy70, 0);
162709	}
162710	break;
162711	case 310: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
162712	{
162713	yylhsminor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, yymsp[-2].minor.yy70, yymsp[-1].minor.yy70, &yymsp[-5].minor.yy0);
162714	}
162715	yymsp[-5].minor.yy49 = yylhsminor.yy49;
162716	break;
162717	case 311: /* window ::= ORDER BY sortlist frame_opt */
162718	{
162719	yymsp[-3].minor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, 0, yymsp[-1].minor.yy70, 0);
162720	}
162721	break;
162722	case 312: /* window ::= nm ORDER BY sortlist frame_opt */
162723	{
162724	yylhsminor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, 0, yymsp[-1].minor.yy70, &yymsp[-4].minor.yy0);
162725	}
162726	yymsp[-4].minor.yy49 = yylhsminor.yy49;
162727	break;
162728	case 313: /* window ::= frame_opt */
162729	case 332: /* filter_over ::= over_clause */ yytestcase(yyruleno==332);
162730	{
162731	yylhsminor.yy49 = yymsp[0].minor.yy49;
162732	}
162733	yymsp[0].minor.yy49 = yylhsminor.yy49;
162734	break;
162735	case 314: /* window ::= nm frame_opt */
162736	{
162737	yylhsminor.yy49 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy49, 0, 0, &yymsp[-1].minor.yy0);
162738	}
162739	yymsp[-1].minor.yy49 = yylhsminor.yy49;
162740	break;
162741	case 315: /* frame_opt ::= */
162742	{
162743	yymsp[1].minor.yy49 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
162744	}
162745	break;
162746	case 316: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
162747	{
162748	yylhsminor.yy49 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy376, yymsp[-1].minor.yy117.eType, yymsp[-1].minor.yy117.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy552);
162749	}
162750	yymsp[-2].minor.yy49 = yylhsminor.yy49;
162751	break;
162752	case 317: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
162753	{
162754	yylhsminor.yy49 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy376, yymsp[-3].minor.yy117.eType, yymsp[-3].minor.yy117.pExpr, yymsp[-1].minor.yy117.eType, yymsp[-1].minor.yy117.pExpr, yymsp[0].minor.yy552);
162755	}
162756	yymsp[-5].minor.yy49 = yylhsminor.yy49;
162757	break;
162758	case 319: /* frame_bound_s ::= frame_bound */
162759	case 321: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==321);
162760	{yylhsminor.yy117 = yymsp[0].minor.yy117;}
162761	yymsp[0].minor.yy117 = yylhsminor.yy117;
162762	break;
162763	case 320: /* frame_bound_s ::= UNBOUNDED PRECEDING */
162764	case 322: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==322);
162765	case 324: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==324);
162766	{yylhsminor.yy117.eType = yymsp[-1].major; yylhsminor.yy117.pExpr = 0;}
162767	yymsp[-1].minor.yy117 = yylhsminor.yy117;
162768	break;
162769	case 323: /* frame_bound ::= expr PRECEDING\|FOLLOWING */
162770	{yylhsminor.yy117.eType = yymsp[0].major; yylhsminor.yy117.pExpr = yymsp[-1].minor.yy404;}
162771	yymsp[-1].minor.yy117 = yylhsminor.yy117;
162772	break;
162773	case 325: /* frame_exclude_opt ::= */
162774	{yymsp[1].minor.yy552 = 0;}
162775	break;
162776	case 326: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
162777	{yymsp[-1].minor.yy552 = yymsp[0].minor.yy552;}
162778	break;
162779	case 327: /* frame_exclude ::= NO OTHERS */
162780	case 328: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==328);
162781	{yymsp[-1].minor.yy552 = yymsp[-1].major; /A-overwrites-X/}
162782	break;
162783	case 329: /* frame_exclude ::= GROUP\|TIES */
162784	{yymsp[0].minor.yy552 = yymsp[0].major; /A-overwrites-X/}
162785	break;
162786	case 330: /* window_clause ::= WINDOW windowdefn_list */
162787	{ yymsp[-1].minor.yy49 = yymsp[0].minor.yy49; }
162788	break;
162789	case 331: /* filter_over ::= filter_clause over_clause */
162790	{
162791	if( yymsp[0].minor.yy49 ){
162792	yymsp[0].minor.yy49->pFilter = yymsp[-1].minor.yy404;
162793	}else{
162794	sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy404);
162795	}
162796	yylhsminor.yy49 = yymsp[0].minor.yy49;
162797	}
162798	yymsp[-1].minor.yy49 = yylhsminor.yy49;
162799	break;
162800	case 333: /* filter_over ::= filter_clause */
162801	{
162802	yylhsminor.yy49 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
162803	if( yylhsminor.yy49 ){
162804	yylhsminor.yy49->eFrmType = TK_FILTER;
162805	yylhsminor.yy49->pFilter = yymsp[0].minor.yy404;
162806	}else{
162807	sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy404);
162808	}
162809	}
162810	yymsp[0].minor.yy49 = yylhsminor.yy49;
162811	break;
162812	case 334: /* over_clause ::= OVER LP window RP */
162813	{
162814	yymsp[-3].minor.yy49 = yymsp[-1].minor.yy49;
162815	assert( yymsp[-3].minor.yy49!=0 );
162816	}
162817	break;
162818	case 335: /* over_clause ::= OVER nm */
162819	{
162820	yymsp[-1].minor.yy49 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
162821	if( yymsp[-1].minor.yy49 ){
162822	yymsp[-1].minor.yy49->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
162823	}
162824	}
162825	break;
162826	case 336: /* filter_clause ::= FILTER LP WHERE expr RP */
162827	{ yymsp[-4].minor.yy404 = yymsp[-1].minor.yy404; }
162828	break;
162829	default:
162830	/* (337) input ::= cmdlist */ yytestcase(yyruleno==337);
162831	/* (338) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==338);
162832	/* (339) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=339);
	@@ -191338,12 +191502,12 @@
191502	if( pStr->zBuf==0 ){
191503	jsonInit(pStr, ctx);
191504	jsonAppendChar(pStr, '{');
191505	}else if( pStr->nUsed>1 ){
191506	jsonAppendChar(pStr, ',');

191507	}
191508	pStr->pCtx = ctx;
191509	z = (const char*)sqlite3_value_text(argv[0]);
191510	n = (u32)sqlite3_value_bytes(argv[0]);
191511	jsonAppendString(pStr, z, n);
191512	jsonAppendChar(pStr, ':');
191513	jsonAppendValue(pStr, argv[1]);
	@@ -208318,17 +208482,33 @@
208482	** If not, use sqlite3_realloc() to grow the buffer so that there is.
208483	**
208484	** If successful, return zero. Otherwise, if an OOM condition is encountered,
208485	** set *pRc to SQLITE_NOMEM and return non-zero.
208486	*/
208487	static int sessionBufferGrow(SessionBuffer p, i64 nByte, int pRc){
208488	#define SESSION_MAX_BUFFER_SZ (0x7FFFFF00 - 1)
208489	i64 nReq = p->nBuf + nByte;
208490	if( *pRc==SQLITE_OK && nReq>p->nAlloc ){
208491	u8 *aNew;
208492	i64 nNew = p->nAlloc ? p->nAlloc : 128;
208493
208494	do {
208495	nNew = nNew*2;
208496	}while( nNew<nReq );
208497
208498	/* The value of SESSION_MAX_BUFFER_SZ is copied from the implementation
208499	** of sqlite3_realloc64(). Allocations greater than this size in bytes
208500	** always fail. It is used here to ensure that this routine can always
208501	** allocate up to this limit - instead of up to the largest power of
208502	** two smaller than the limit. */
208503	if( nNew>SESSION_MAX_BUFFER_SZ ){
208504	nNew = SESSION_MAX_BUFFER_SZ;
208505	if( nNew<nReq ){
208506	*pRc = SQLITE_NOMEM;
208507	return 1;
208508	}
208509	}
208510
208511	aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
208512	if( 0==aNew ){
208513	*pRc = SQLITE_NOMEM;
208514	}else{
	@@ -229418,17 +229598,19 @@
229598	}
229599	if( iBest<0 ) break;
229600
229601	nInst++;
229602	if( nInst>=pCsr->nInstAlloc ){
229603	int nNewSize = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
229604	aInst = (int*)sqlite3_realloc64(
229605	pCsr->aInst, nNewSizesizeof(int)3
229606	);
229607	if( aInst ){
229608	pCsr->aInst = aInst;
229609	pCsr->nInstAlloc = nNewSize;
229610	}else{
229611	nInst--;
229612	rc = SQLITE_NOMEM;
229613	break;
229614	}
229615	}
229616
	@@ -230259,11 +230441,11 @@
230441	int nArg, /* Number of args */
230442	sqlite3_value *apUnused / Function arguments */
230443	){
230444	assert( nArg==0 );
230445	UNUSED_PARAM2(nArg, apUnused);
230446	sqlite3_result_text(pCtx, "fts5: 2021-06-03 18:56:42 4a587c3492faa99490fd67ca1de9fceafcdc12d220f42817791923be258b73f1", -1, SQLITE_TRANSIENT);
230447	}
230448
230449	/*
230450	** Return true if zName is the extension on one of the shadow tables used
230451	** by this module.
	@@ -235185,12 +235367,12 @@
235367	}
235368	#endif /* SQLITE_CORE */
235369	#endif /* !defined(SQLITE_CORE) \|\| defined(SQLITE_ENABLE_STMTVTAB) */
235370
235371	/************ End of stmt.c **********************************************/
235372	#if __LINE__!=235372
235373	#undef SQLITE_SOURCE_ID
235374	#define SQLITE_SOURCE_ID "2021-06-03 18:56:42 4a587c3492faa99490fd67ca1de9fceafcdc12d220f42817791923be258balt2"
235375	#endif
235376	/* Return the source-id for this library */
235377	SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
235378	/************************ End of sqlite3.c ****************************/
235379

M src/sqlite3.h

+1 -1

		--- src/sqlite3.h
		+++ src/sqlite3.h
		@@ -123,11 +123,11 @@
123	123	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
124	124	** [sqlite_version()] and [sqlite_source_id()].
125	125	*/
126	126	#define SQLITE_VERSION "3.36.0"
127	127	#define SQLITE_VERSION_NUMBER 3036000
128		-#define SQLITE_SOURCE_ID "2021-05-17 17:14:38 ace12a3912a4fdc2f0e741361ec705652a11b6f5e3548d54bd6f273671ba1e09"
	128	+#define SQLITE_SOURCE_ID "2021-06-03 18:56:42 4a587c3492faa99490fd67ca1de9fceafcdc12d220f42817791923be258b73f1"
129	129
130	130	/*
131	131	** CAPI3REF: Run-Time Library Version Numbers
132	132	** KEYWORDS: sqlite3_version sqlite3_sourceid
133	133	**
134	134

	--- src/sqlite3.h
	+++ src/sqlite3.h
	@@ -123,11 +123,11 @@
123	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
124	** [sqlite_version()] and [sqlite_source_id()].
125	*/
126	#define SQLITE_VERSION "3.36.0"
127	#define SQLITE_VERSION_NUMBER 3036000
128	#define SQLITE_SOURCE_ID "2021-05-17 17:14:38 ace12a3912a4fdc2f0e741361ec705652a11b6f5e3548d54bd6f273671ba1e09"
129
130	/*
131	** CAPI3REF: Run-Time Library Version Numbers
132	** KEYWORDS: sqlite3_version sqlite3_sourceid
133	**
134

	--- src/sqlite3.h
	+++ src/sqlite3.h
	@@ -123,11 +123,11 @@
123	** [sqlite3_libversion_number()], [sqlite3_sourceid()],
124	** [sqlite_version()] and [sqlite_source_id()].
125	*/
126	#define SQLITE_VERSION "3.36.0"
127	#define SQLITE_VERSION_NUMBER 3036000
128	#define SQLITE_SOURCE_ID "2021-06-03 18:56:42 4a587c3492faa99490fd67ca1de9fceafcdc12d220f42817791923be258b73f1"
129
130	/*
131	** CAPI3REF: Run-Time Library Version Numbers
132	** KEYWORDS: sqlite3_version sqlite3_sourceid
133	**
134

Fossil SCM

Keyboard Shortcuts