e011698 Update sqlite to 3.8.4.1 — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Update sqlite to 3.8.4.1

Baptiste Daroussin committed 12 years ago

commit e011698c7ec44db347ee33faa117f2340cbffff3
parent 4fee372

3 files changed +12026 -8709

modified external/sqlite/shell.c

@@ -45,14 +45,17 @@

 # include <sys/types.h>
 #endif
 #ifdef HAVE_EDITLINE
 # include <editline/editline.h>
 #endif
 #if defined(HAVE_READLINE) && HAVE_READLINE==1
 #if defined(HAVE_READLINE) && HAVE_READLINE!=0
 # include <readline/readline.h>
 # include <readline/history.h>
 #else
 # undef HAVE_READLINE
 #endif
 #if !defined(HAVE_EDITLINE) && (!defined(HAVE_READLINE) || HAVE_READLINE!=1)
 #if defined(HAVE_EDITLINE) && !defined(HAVE_READLINE)
 # define HAVE_READLINE 1
 # include <editline/readline.h>
 #endif
 #if !defined(HAVE_READLINE)
 # define add_history(X)
 # define read_history(X)
 # define write_history(X)

@@ -62,7 +65,9 @@

 #if defined(_WIN32) || defined(WIN32)
 # include <io.h>
 #define isatty(h) _isatty(h)
 #define access(f,m) _access((f),(m))
 #ifndef access
 # define access(f,m) _access((f),(m))
 #endif
 #undef popen
 #define popen _popen
 #undef pclose

@@ -71,12 +76,12 @@

 /* Make sure isatty() has a prototype.
 */
 extern int isatty(int);
 #endif
 /* popen and pclose are not C89 functions and so are sometimes omitted from
 ** the <stdio.h> header */
 FILE *popen(const char*,const char*);
 int pclose(FILE*);
 extern FILE *popen(const char*,const char*);
 extern int pclose(FILE*);
 #endif
 #if defined(_WIN32_WCE)
 /* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()

@@ -86,21 +91,38 @@ int pclose(FILE*);

 #define isatty(x) 1
 #endif
 /* True if the timer is enabled */
 static int enableTimer = 0;
 /* ctype macros that work with signed characters */
 #define IsSpace(X)  isspace((unsigned char)X)
 #define IsDigit(X)  isdigit((unsigned char)X)
 #define ToLower(X)  (char)tolower((unsigned char)X)
 /* True if the timer is enabled */
 static int enableTimer = 0;
 /* Return the current wall-clock time */
 static sqlite3_int64 timeOfDay(void){
   static sqlite3_vfs *clockVfs = 0;
   sqlite3_int64 t;
   if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
   if( clockVfs->iVersion>=1 && clockVfs->xCurrentTimeInt64!=0 ){
     clockVfs->xCurrentTimeInt64(clockVfs, &t);
   }else{
     double r;
     clockVfs->xCurrentTime(clockVfs, &r);
     t = (sqlite3_int64)(r*86400000.0);
   }
   return t;
 }
 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WRS_KERNEL) \
  && !defined(__minux)
 #include <sys/time.h>
 #include <sys/resource.h>
 /* Saved resource information for the beginning of an operation */
 static struct rusage sBegin;
 static struct rusage sBegin;  /* CPU time at start */
 static sqlite3_int64 iBegin;  /* Wall-clock time at start */
 /*
 ** Begin timing an operation

@@ -108,6 +130,7 @@ static struct rusage sBegin;

 static void beginTimer(void){
   if( enableTimer ){
     getrusage(RUSAGE_SELF, &sBegin);
     iBegin = timeOfDay();
   }
 }

@@ -123,8 +146,10 @@ static double timeDiff(struct timeval *pStart, struct timeval *pEnd){

 static void endTimer(void){
   if( enableTimer ){
     struct rusage sEnd;
     sqlite3_int64 iEnd = timeOfDay();
     getrusage(RUSAGE_SELF, &sEnd);
     printf("CPU Time: user %f sys %f\n",
     printf("Run Time: real %.3f user %f sys %f\n",
        (iEnd - iBegin)*0.001,
        timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
        timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
   }

@@ -142,6 +167,7 @@ static void endTimer(void){

 static HANDLE hProcess;
 static FILETIME ftKernelBegin;
 static FILETIME ftUserBegin;
 static sqlite3_int64 ftWallBegin;
 typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME, LPFILETIME, LPFILETIME);
 static GETPROCTIMES getProcessTimesAddr = NULL;

@@ -179,6 +205,7 @@ static void beginTimer(void){

   if( enableTimer && getProcessTimesAddr ){
     FILETIME ftCreation, ftExit;
     getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelBegin, &ftUserBegin);
     ftWallBegin = timeOfDay();
   }
 }

@@ -195,8 +222,10 @@ static double timeDiff(FILETIME *pStart, FILETIME *pEnd){

 static void endTimer(void){
   if( enableTimer && getProcessTimesAddr){
     FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
     sqlite3_int64 ftWallEnd = timeOfDay();
     getProcessTimesAddr(hProcess, &ftCreation, &ftExit, &ftKernelEnd, &ftUserEnd);
     printf("CPU Time: user %f sys %f\n",
     printf("Run Time: real %.3f user %f sys %f\n",
        (ftWallEnd - ftWallBegin)*0.001,
        timeDiff(&ftUserBegin, &ftUserEnd),
        timeDiff(&ftKernelBegin, &ftKernelEnd));
   }

@@ -389,7 +418,7 @@ static char *one_input_line(FILE *in, char *zPrior, int isContinuation){

     zResult = local_getline(zPrior, in);
   }else{
     zPrompt = isContinuation ? continuePrompt : mainPrompt;
 #if defined(HAVE_READLINE) && HAVE_READLINE==1
 #if defined(HAVE_READLINE)
     free(zPrior);
     zResult = readline(zPrompt);
     if( zResult && *zResult ) add_history(zResult);

@@ -417,6 +446,7 @@ struct previous_mode_data {

 struct callback_data {
   sqlite3 *db;           /* The database */
   int echoOn;            /* True to echo input commands */
   int autoEQP;           /* Run EXPLAIN QUERY PLAN prior to seach SQL statement */
   int statsOn;           /* True to display memory stats before each finalize */
   int cnt;               /* Number of records displayed so far */
   FILE *out;             /* Write results here */

@@ -436,9 +466,13 @@ struct callback_data {

                          ** .explain ON */
   char outfile[FILENAME_MAX]; /* Filename for *out */
   const char *zDbFilename;    /* name of the database file */
   char *zFreeOnClose;         /* Filename to free when closing */
   const char *zVfs;           /* Name of VFS to use */
   sqlite3_stmt *pStmt;   /* Current statement if any. */
   FILE *pLog;            /* Write log output here */
   int *aiIndent;         /* Array of indents used in MODE_Explain */
   int nIndent;           /* Size of array aiIndent[] */
   int iIndent;           /* Index of current op in aiIndent[] */
 };
 /*

@@ -554,7 +588,7 @@ static void output_c_string(FILE *out, const char *z){

     }else if( c=='\r' ){
       fputc('\\', out);
       fputc('r', out);
     }else if( !isprint(c) ){
     }else if( !isprint(c&0xff) ){
       fprintf(out, "\\%03o", c&0xff);
     }else{
       fputc(c, out);

@@ -569,6 +603,7 @@ static void output_c_string(FILE *out, const char *z){

 */
 static void output_html_string(FILE *out, const char *z){
   int i;
   if( z==0 ) z = "";
   while( *z ){
     for(i=0;   z[i]
             && z[i]!='<'

@@ -740,10 +775,15 @@ static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int

         }else{
            w = 10;
         }
         if( p->mode==MODE_Explain && azArg[i] &&
            strlen30(azArg[i])>w ){
         if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){
           w = strlen30(azArg[i]);
         }
         if( i==1 && p->aiIndent && p->pStmt ){
           if( p->iIndent<p->nIndent ){
             fprintf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
           }
           p->iIndent++;
         }
         if( w<0 ){
           fprintf(p->out,"%*.*s%s",-w,-w,
               azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": "  ");

@@ -971,10 +1011,10 @@ static int run_table_dump_query(

   int nResult;
   int i;
   const char *z;
   rc = sqlite3_prepare(p->db, zSelect, -1, &pSelect, 0);
   rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
   if( rc!=SQLITE_OK || !pSelect ){
     fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
     p->nErr++;
     if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
     return rc;
   }
   rc = sqlite3_step(pSelect);

@@ -1001,7 +1041,7 @@ static int run_table_dump_query(

   rc = sqlite3_finalize(pSelect);
   if( rc!=SQLITE_OK ){
     fprintf(p->out, "/**** ERROR: (%d) %s *****/\n", rc, sqlite3_errmsg(p->db));
     p->nErr++;
     if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
   }
   return rc;
 }

@@ -1117,6 +1157,104 @@ static int display_stats(

 }
 /*
 ** Parameter azArray points to a zero-terminated array of strings. zStr
 ** points to a single nul-terminated string. Return non-zero if zStr
 ** is equal, according to strcmp(), to any of the strings in the array.
 ** Otherwise, return zero.
 */
 static int str_in_array(const char *zStr, const char **azArray){
   int i;
   for(i=0; azArray[i]; i++){
     if( 0==strcmp(zStr, azArray[i]) ) return 1;
   }
   return 0;
 }
 /*
 ** If compiled statement pSql appears to be an EXPLAIN statement, allocate
 ** and populate the callback_data.aiIndent[] array with the number of
 ** spaces each opcode should be indented before it is output.
 **
 ** The indenting rules are:
 **
 **     * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
 **       all opcodes that occur between the p2 jump destination and the opcode
 **       itself by 2 spaces.
 **
 **     * For each "Goto", if the jump destination is earlier in the program
 **       and ends on one of:
 **          Yield  SeekGt  SeekLt  RowSetRead  Rewind
 **       or if the P1 parameter is one instead of zero,
 **       then indent all opcodes between the earlier instruction
 **       and "Goto" by 2 spaces.
 */
 static void explain_data_prepare(struct callback_data *p, sqlite3_stmt *pSql){
   const char *zSql;               /* The text of the SQL statement */
   const char *z;                  /* Used to check if this is an EXPLAIN */
   int *abYield = 0;               /* True if op is an OP_Yield */
   int nAlloc = 0;                 /* Allocated size of p->aiIndent[], abYield */
   int iOp;                        /* Index of operation in p->aiIndent[] */
   const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext", 0 };
   const char *azYield[] = { "Yield", "SeekLt", "SeekGt", "RowSetRead", "Rewind", 0 };
   const char *azGoto[] = { "Goto", 0 };
   /* Try to figure out if this is really an EXPLAIN statement. If this
   ** cannot be verified, return early.  */
   zSql = sqlite3_sql(pSql);
   if( zSql==0 ) return;
   for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
   if( sqlite3_strnicmp(z, "explain", 7) ) return;
   for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
     int i;
     int iAddr = sqlite3_column_int(pSql, 0);
     const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
     /* Set p2 to the P2 field of the current opcode. Then, assuming that
     ** p2 is an instruction address, set variable p2op to the index of that
     ** instruction in the aiIndent[] array. p2 and p2op may be different if
     ** the current instruction is part of a sub-program generated by an
     ** SQL trigger or foreign key.  */
     int p2 = sqlite3_column_int(pSql, 3);
     int p2op = (p2 + (iOp-iAddr));
     /* Grow the p->aiIndent array as required */
     if( iOp>=nAlloc ){
       nAlloc += 100;
       p->aiIndent = (int*)sqlite3_realloc(p->aiIndent, nAlloc*sizeof(int));
       abYield = (int*)sqlite3_realloc(abYield, nAlloc*sizeof(int));
     }
     abYield[iOp] = str_in_array(zOp, azYield);
     p->aiIndent[iOp] = 0;
     p->nIndent = iOp+1;
     if( str_in_array(zOp, azNext) ){
       for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
     }
     if( str_in_array(zOp, azGoto) && p2op<p->nIndent
      && (abYield[p2op] || sqlite3_column_int(pSql, 2))
     ){
       for(i=p2op+1; i<iOp; i++) p->aiIndent[i] += 2;
     }
   }
   p->iIndent = 0;
   sqlite3_free(abYield);
   sqlite3_reset(pSql);
 }
 /*
 ** Free the array allocated by explain_data_prepare().
 */
 static void explain_data_delete(struct callback_data *p){
   sqlite3_free(p->aiIndent);
   p->aiIndent = 0;
   p->nIndent = 0;
   p->iIndent = 0;
 }
 /*
 ** Execute a statement or set of statements.  Print
 ** any result rows/columns depending on the current mode
 ** set via the supplied callback.

@@ -1168,6 +1306,23 @@ static int shell_exec(

         fprintf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
       }
       /* Show the EXPLAIN QUERY PLAN if .eqp is on */
       if( pArg && pArg->autoEQP ){
         sqlite3_stmt *pExplain;
         char *zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s", sqlite3_sql(pStmt));
         rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
         if( rc==SQLITE_OK ){
           while( sqlite3_step(pExplain)==SQLITE_ROW ){
             fprintf(pArg->out,"--EQP-- %d,", sqlite3_column_int(pExplain, 0));
             fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1));
             fprintf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2));
             fprintf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3));
           }
         }
         sqlite3_finalize(pExplain);
         sqlite3_free(zEQP);
       }
       /* Output TESTCTRL_EXPLAIN text of requested */
       if( pArg && pArg->mode==MODE_Explain ){
         const char *zExplain = 0;

@@ -1177,6 +1332,12 @@ static int shell_exec(

         }
       }
       /* If the shell is currently in ".explain" mode, gather the extra
       ** data required to add indents to the output.*/
       if( pArg && pArg->mode==MODE_Explain ){
         explain_data_prepare(pArg, pStmt);
       }
       /* perform the first step.  this will tell us if we
       ** have a result set or not and how wide it is.
       */

@@ -1194,7 +1355,7 @@ static int shell_exec(

             char **azCols = (char **)pData;      /* Names of result columns */
             char **azVals = &azCols[nCol];       /* Results */
             int *aiTypes = (int *)&azVals[nCol]; /* Result types */
             int i;
             int i, x;
             assert(sizeof(int) <= sizeof(char *));
             /* save off ptrs to column names */
             for(i=0; i<nCol; i++){

@@ -1203,8 +1364,12 @@ static int shell_exec(

             do{
               /* extract the data and data types */
               for(i=0; i<nCol; i++){
                 azVals[i] = (char *)sqlite3_column_text(pStmt, i);
                 aiTypes[i] = sqlite3_column_type(pStmt, i);
                 aiTypes[i] = x = sqlite3_column_type(pStmt, i);
                 if( x==SQLITE_BLOB && pArg && pArg->mode==MODE_Insert ){
                   azVals[i] = "";
                 }else{
                   azVals[i] = (char*)sqlite3_column_text(pStmt, i);
                 }
                 if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
                   rc = SQLITE_NOMEM;
                   break; /* from for */

@@ -1230,6 +1395,8 @@ static int shell_exec(

         }
       }
       explain_data_delete(pArg);
       /* print usage stats if stats on */
       if( pArg && pArg->statsOn ){
         display_stats(db, pArg, 0);

@@ -1280,7 +1447,7 @@ static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){

   if( strcmp(zTable, "sqlite_sequence")==0 ){
     zPrepStmt = "DELETE FROM sqlite_sequence;\n";
   }else if( strcmp(zTable, "sqlite_stat1")==0 ){
   }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
     fprintf(p->out, "ANALYZE sqlite_master;\n");
   }else if( strncmp(zTable, "sqlite_", 7)==0 ){
     return 0;

@@ -1312,7 +1479,7 @@ static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){

     zTableInfo = appendText(zTableInfo, zTable, '"');
     zTableInfo = appendText(zTableInfo, ");", 0);
     rc = sqlite3_prepare(p->db, zTableInfo, -1, &pTableInfo, 0);
     rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
     free(zTableInfo);
     if( rc!=SQLITE_OK || !pTableInfo ){
       return 1;

@@ -1402,6 +1569,7 @@ static int run_schema_dump_query(

 static char zHelp[] =
   ".backup ?DB? FILE      Backup DB (default \"main\") to FILE\n"
   ".bail ON|OFF           Stop after hitting an error.  Default OFF\n"
   ".clone NEWDB           Clone data into NEWDB from the existing database\n"
   ".databases             List names and files of attached databases\n"
   ".dump ?TABLE? ...      Dump the database in an SQL text format\n"
   "                         If TABLE specified, only dump tables matching\n"

@@ -1433,6 +1601,7 @@ static char zHelp[] =

   "                         tabs     Tab-separated values\n"
   "                         tcl      TCL list elements\n"
   ".nullvalue STRING      Use STRING in place of NULL values\n"
   ".open ?FILENAME?       Close existing database and reopen FILENAME\n"
   ".output FILENAME       Send output to FILENAME\n"
   ".output stdout         Send output to the screen\n"
   ".print STRING...       Print literal STRING\n"

@@ -1440,6 +1609,7 @@ static char zHelp[] =

   ".quit                  Exit this program\n"
   ".read FILENAME         Execute SQL in FILENAME\n"
   ".restore ?DB? FILE     Restore content of DB (default \"main\") from FILE\n"
   ".save FILE             Write in-memory database into FILE\n"
   ".schema ?TABLE?        Show the CREATE statements\n"
   "                         If TABLE specified, only show tables matching\n"
   "                         LIKE pattern TABLE.\n"

@@ -1466,7 +1636,7 @@ static int process_input(struct callback_data *p, FILE *in);

 ** Make sure the database is open.  If it is not, then open it.  If
 ** the database fails to open, print an error message and exit.
 */
 static void open_db(struct callback_data *p){
 static void open_db(struct callback_data *p, int keepAlive){
   if( p->db==0 ){
     sqlite3_initialize();
     sqlite3_open(p->zDbFilename, &p->db);

@@ -1478,6 +1648,7 @@ static void open_db(struct callback_data *p){

     if( db==0 || SQLITE_OK!=sqlite3_errcode(db) ){
       fprintf(stderr,"Error: unable to open database \"%s\": %s\n",
           p->zDbFilename, sqlite3_errmsg(db));
       if( keepAlive ) return;
       exit(1);
     }
 #ifndef SQLITE_OMIT_LOAD_EXTENSION

@@ -1694,7 +1865,7 @@ static void csv_append_char(CSVReader *p, int c){

 **   +  Report syntax errors on stderr
 */
 static char *csv_read_one_field(CSVReader *p){
   int c, pc;
   int c, pc, ppc;
   int cSep = p->cSeparator;
   p->n = 0;
   c = fgetc(p->in);

@@ -1705,7 +1876,7 @@ static char *csv_read_one_field(CSVReader *p){

   if( c=='"' ){
     int startLine = p->nLine;
     int cQuote = c;
     pc = 0;
     pc = ppc = 0;
     while( 1 ){
       c = fgetc(p->in);
       if( c=='\n' ) p->nLine++;

@@ -1717,7 +1888,7 @@ static char *csv_read_one_field(CSVReader *p){

       }
       if( (c==cSep && pc==cQuote)
        || (c=='\n' && pc==cQuote)
        || (c=='\n' && pc=='\r' && p->n>=2 && p->z[p->n-2]==cQuote)
        || (c=='\n' && pc=='\r' && ppc==cQuote)
        || (c==EOF && pc==cQuote)
       ){
         do{ p->n--; }while( p->z[p->n]!=cQuote );

@@ -1735,6 +1906,7 @@ static char *csv_read_one_field(CSVReader *p){

         break;
       }
       csv_append_char(p, c);
       ppc = pc;
       pc = c;
     }
   }else{

@@ -1744,7 +1916,7 @@ static char *csv_read_one_field(CSVReader *p){

     }
     if( c=='\n' ){
       p->nLine++;
       if( p->n>1 && p->z[p->n-1]=='\r' ) p->n--;
       if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
     }
     p->cTerm = c;
   }

@@ -1753,6 +1925,219 @@ static char *csv_read_one_field(CSVReader *p){

 }
 /*
 ** Try to transfer data for table zTable.  If an error is seen while
 ** moving forward, try to go backwards.  The backwards movement won't
 ** work for WITHOUT ROWID tables.
 */
 static void tryToCloneData(
   struct callback_data *p,
   sqlite3 *newDb,
   const char *zTable
 ){
   sqlite3_stmt *pQuery = 0;
   sqlite3_stmt *pInsert = 0;
   char *zQuery = 0;
   char *zInsert = 0;
   int rc;
   int i, j, n;
   int nTable = (int)strlen(zTable);
   int k = 0;
   int cnt = 0;
   const int spinRate = 10000;
   zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
   rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
   if( rc ){
     fprintf(stderr, "Error %d: %s on [%s]\n",
             sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
             zQuery);
     goto end_data_xfer;
   }
   n = sqlite3_column_count(pQuery);
   zInsert = sqlite3_malloc(200 + nTable + n*3);
   if( zInsert==0 ){
     fprintf(stderr, "out of memory\n");
     goto end_data_xfer;
   }
   sqlite3_snprintf(200+nTable,zInsert,
                    "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
   i = (int)strlen(zInsert);
   for(j=1; j<n; j++){
     memcpy(zInsert+i, ",?", 2);
     i += 2;
   }
   memcpy(zInsert+i, ");", 3);
   rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
   if( rc ){
     fprintf(stderr, "Error %d: %s on [%s]\n",
             sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
             zQuery);
     goto end_data_xfer;
   }
   for(k=0; k<2; k++){
     while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
       for(i=0; i<n; i++){
         switch( sqlite3_column_type(pQuery, i) ){
           case SQLITE_NULL: {
             sqlite3_bind_null(pInsert, i+1);
             break;
           }
           case SQLITE_INTEGER: {
             sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
             break;
           }
           case SQLITE_FLOAT: {
             sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
             break;
           }
           case SQLITE_TEXT: {
             sqlite3_bind_text(pInsert, i+1,
                              (const char*)sqlite3_column_text(pQuery,i),
                              -1, SQLITE_STATIC);
             break;
           }
           case SQLITE_BLOB: {
             sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
                                             sqlite3_column_bytes(pQuery,i),
                                             SQLITE_STATIC);
             break;
           }
         }
       } /* End for */
       rc = sqlite3_step(pInsert);
       if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
         fprintf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
                         sqlite3_errmsg(newDb));
       }
       sqlite3_reset(pInsert);
       cnt++;
       if( (cnt%spinRate)==0 ){
         printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
         fflush(stdout);
       }
     } /* End while */
     if( rc==SQLITE_DONE ) break;
     sqlite3_finalize(pQuery);
     sqlite3_free(zQuery);
     zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
                              zTable);
     rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
     if( rc ){
       fprintf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
       break;
     }
   } /* End for(k=0...) */
 end_data_xfer:
   sqlite3_finalize(pQuery);
   sqlite3_finalize(pInsert);
   sqlite3_free(zQuery);
   sqlite3_free(zInsert);
 }
 /*
 ** Try to transfer all rows of the schema that match zWhere.  For
 ** each row, invoke xForEach() on the object defined by that row.
 ** If an error is encountered while moving forward through the
 ** sqlite_master table, try again moving backwards.
 */
 static void tryToCloneSchema(
   struct callback_data *p,
   sqlite3 *newDb,
   const char *zWhere,
   void (*xForEach)(struct callback_data*,sqlite3*,const char*)
 ){
   sqlite3_stmt *pQuery = 0;
   char *zQuery = 0;
   int rc;
   const unsigned char *zName;
   const unsigned char *zSql;
   char *zErrMsg = 0;
   zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
                            " WHERE %s", zWhere);
   rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
   if( rc ){
     fprintf(stderr, "Error: (%d) %s on [%s]\n",
                     sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
                     zQuery);
     goto end_schema_xfer;
   }
   while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
     zName = sqlite3_column_text(pQuery, 0);
     zSql = sqlite3_column_text(pQuery, 1);
     printf("%s... ", zName); fflush(stdout);
     sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
     if( zErrMsg ){
       fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
       sqlite3_free(zErrMsg);
       zErrMsg = 0;
     }
     if( xForEach ){
       xForEach(p, newDb, (const char*)zName);
     }
     printf("done\n");
   }
   if( rc!=SQLITE_DONE ){
     sqlite3_finalize(pQuery);
     sqlite3_free(zQuery);
     zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
                              " WHERE %s ORDER BY rowid DESC", zWhere);
     rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
     if( rc ){
       fprintf(stderr, "Error: (%d) %s on [%s]\n",
                       sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
                       zQuery);
       goto end_schema_xfer;
     }
     while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
       zName = sqlite3_column_text(pQuery, 0);
       zSql = sqlite3_column_text(pQuery, 1);
       printf("%s... ", zName); fflush(stdout);
       sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
       if( zErrMsg ){
         fprintf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
         sqlite3_free(zErrMsg);
         zErrMsg = 0;
       }
       if( xForEach ){
         xForEach(p, newDb, (const char*)zName);
       }
       printf("done\n");
     }
   }
 end_schema_xfer:
   sqlite3_finalize(pQuery);
   sqlite3_free(zQuery);
 }
 /*
 ** Open a new database file named "zNewDb".  Try to recover as much information
 ** as possible out of the main database (which might be corrupt) and write it
 ** into zNewDb.
 */
 static void tryToClone(struct callback_data *p, const char *zNewDb){
   int rc;
   sqlite3 *newDb = 0;
   if( access(zNewDb,0)==0 ){
     fprintf(stderr, "File \"%s\" already exists.\n", zNewDb);
     return;
   }
   rc = sqlite3_open(zNewDb, &newDb);
   if( rc ){
     fprintf(stderr, "Cannot create output database: %s\n",
             sqlite3_errmsg(newDb));
   }else{
     sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
     tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
     tryToCloneSchema(p, newDb, "type!='table'", 0);
     sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
   }
   sqlite3_close(newDb);
 }
 /*
 ** If an input line begins with "." then invoke this routine to
 ** process that line.
 **

@@ -1794,7 +2179,9 @@ static int do_meta_command(char *zLine, struct callback_data *p){

   if( nArg==0 ) return 0; /* no tokens, no error */
   n = strlen30(azArg[0]);
   c = azArg[0][0];
   if( c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0 ){
   if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
    || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
   ){
     const char *zDestFile = 0;
     const char *zDb = 0;
     sqlite3 *pDest;

@@ -1830,7 +2217,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

       sqlite3_close(pDest);
       return 1;
     }
     open_db(p);
     open_db(p, 0);
     pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
     if( pBackup==0 ){
       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));

@@ -1859,10 +2246,14 @@ static int do_meta_command(char *zLine, struct callback_data *p){

     test_breakpoint();
   }else
   if( c=='c' && strncmp(azArg[0], "clone", n)==0 && nArg>1 && nArg<3 ){
     tryToClone(p, azArg[1]);
   }else
   if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 && nArg==1 ){
     struct callback_data data;
     char *zErrMsg = 0;
     open_db(p);
     open_db(p, 0);
     memcpy(&data, p, sizeof(data));
     data.showHeader = 1;
     data.mode = MODE_Column;

@@ -1879,7 +2270,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

   }else
   if( c=='d' && strncmp(azArg[0], "dump", n)==0 && nArg<3 ){
     open_db(p);
     open_db(p, 0);
     /* When playing back a "dump", the content might appear in an order
     ** which causes immediate foreign key constraints to be violated.
     ** So disable foreign-key constraint enforcement to prevent problems. */

@@ -1931,6 +2322,10 @@ static int do_meta_command(char *zLine, struct callback_data *p){

     p->echoOn = booleanValue(azArg[1]);
   }else
   if( c=='e' && strncmp(azArg[0], "eqp", n)==0 && nArg>1 && nArg<3 ){
     p->autoEQP = booleanValue(azArg[1]);
   }else
   if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
     if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
     rc = 2;

@@ -1954,7 +2349,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

       */
       p->mode = MODE_Explain;
       p->showHeader = 1;
       memset(p->colWidth,0,ArraySize(p->colWidth));
       memset(p->colWidth,0,sizeof(p->colWidth));
       p->colWidth[0] = 4;                  /* addr */
       p->colWidth[1] = 13;                 /* opcode */
       p->colWidth[2] = 4;                  /* P1 */

@@ -1998,7 +2393,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

     seenInterrupt = 0;
     memset(&sCsv, 0, sizeof(sCsv));
     open_db(p);
     open_db(p, 0);
     nSep = strlen30(p->separator);
     if( nSep==0 ){
       fprintf(stderr, "Error: non-null separator required for import\n");

@@ -2031,7 +2426,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

       return 1;
     }
     nByte = strlen30(zSql);
     rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
     rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
     if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(db))==0 ){
       char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
       char cSep = '(';

@@ -2057,7 +2452,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

         xCloser(sCsv.in);
         return 1;
       }
       rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
       rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
     }
     sqlite3_free(zSql);
     if( rc ){

@@ -2084,7 +2479,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

     }
     zSql[j++] = ')';
     zSql[j] = 0;
     rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
     rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
     sqlite3_free(zSql);
     if( rc ){
       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(db));

@@ -2136,7 +2531,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

   if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg<3 ){
     struct callback_data data;
     char *zErrMsg = 0;
     open_db(p);
     open_db(p, 0);
     memcpy(&data, p, sizeof(data));
     data.showHeader = 0;
     data.mode = MODE_List;

@@ -2202,7 +2597,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

     char *zErrMsg = 0;
     zFile = azArg[1];
     zProc = nArg>=3 ? azArg[2] : 0;
     open_db(p);
     open_db(p, 0);
     rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
     if( rc!=SQLITE_OK ){
       fprintf(stderr, "Error: %s\n", zErrMsg);

@@ -2268,6 +2663,26 @@ static int do_meta_command(char *zLine, struct callback_data *p){

                      "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]);
   }else
   if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
     sqlite3 *savedDb = p->db;
     const char *zSavedFilename = p->zDbFilename;
     char *zNewFilename = 0;
     p->db = 0;
     if( nArg>=2 ){
       p->zDbFilename = zNewFilename = sqlite3_mprintf("%s", azArg[1]);
     }
     open_db(p, 1);
     if( p->db!=0 ){
       sqlite3_close(savedDb);
       sqlite3_free(p->zFreeOnClose);
       p->zFreeOnClose = zNewFilename;
     }else{
       sqlite3_free(zNewFilename);
       p->db = savedDb;
       p->zDbFilename = zSavedFilename;
     }
   }else
   if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){
     if( p->outfile[0]=='|' ){
       pclose(p->out);

@@ -2351,7 +2766,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

       sqlite3_close(pSrc);
       return 1;
     }
     open_db(p);
     open_db(p, 0);
     pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
     if( pBackup==0 ){
       fprintf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));

@@ -2381,7 +2796,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

   if( c=='s' && strncmp(azArg[0], "schema", n)==0 && nArg<3 ){
     struct callback_data data;
     char *zErrMsg = 0;
     open_db(p);
     open_db(p, 0);
     memcpy(&data, p, sizeof(data));
     data.showHeader = 0;
     data.mode = MODE_Semi;

@@ -2483,6 +2898,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

   if( c=='s' && strncmp(azArg[0], "show", n)==0 && nArg==1 ){
     int i;
     fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");
     fprintf(p->out,"%9.9s: %s\n","eqp", p->autoEQP ? "on" : "off");
     fprintf(p->out,"%9.9s: %s\n","explain", p->explainPrev.valid ? "on" :"off");
     fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");
     fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);

@@ -2512,7 +2928,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

     int nRow, nAlloc;
     char *zSql = 0;
     int ii;
     open_db(p);
     open_db(p, 0);
     rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
     if( rc ) return rc;
     zSql = sqlite3_mprintf(

@@ -2612,7 +3028,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

     int testctrl = -1;
     int rc = 0;
     int i, n;
     open_db(p);
     open_db(p, 0);
     /* convert testctrl text option to value. allow any unique prefix
     ** of the option name, or a numerical value. */

@@ -2711,7 +3127,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

   }else
   if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 && nArg==2 ){
     open_db(p);
     open_db(p, 0);
     sqlite3_busy_timeout(p->db, (int)integerValue(azArg[1]));
   }else

@@ -2722,7 +3138,7 @@ static int do_meta_command(char *zLine, struct callback_data *p){

   }else
   if( c=='t' && strncmp(azArg[0], "trace", n)==0 && nArg>1 ){
     open_db(p);
     open_db(p, 0);
     output_file_close(p->traceOut);
     p->traceOut = output_file_open(azArg[1]);
 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)

@@ -2875,7 +3291,10 @@ static int process_input(struct callback_data *p, FILE *in){

       seenInterrupt = 0;
     }
     lineno++;
     if( nSql==0 && _all_whitespace(zLine) ) continue;
     if( nSql==0 && _all_whitespace(zLine) ){
       if( p->echoOn ) printf("%s\n", zLine);
       continue;
     }
     if( zLine && zLine[0]=='.' && nSql==0 ){
       if( p->echoOn ) printf("%s\n", zLine);
       rc = do_meta_command(zLine, p);

@@ -2914,7 +3333,7 @@ static int process_input(struct callback_data *p, FILE *in){

     if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
                 && sqlite3_complete(zSql) ){
       p->cnt = 0;
       open_db(p);
       open_db(p, 0);
       BEGIN_TIMER;
       rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
       END_TIMER;

@@ -2937,6 +3356,7 @@ static int process_input(struct callback_data *p, FILE *in){

       }
       nSql = 0;
     }else if( nSql && _all_whitespace(zSql) ){
       if( p->echoOn ) printf("%s\n", zSql);
       nSql = 0;
     }
   }

@@ -3115,6 +3535,26 @@ static void main_init(struct callback_data *data) {

 }
 /*
 ** Output text to the console in a font that attracts extra attention.
 */
 #ifdef _WIN32
 static void printBold(const char *zText){
   HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
   CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
   GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
   SetConsoleTextAttribute(out,
          FOREGROUND_RED|FOREGROUND_INTENSITY
   );
   printf("%s", zText);
   SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
 }
 #else
 static void printBold(const char *zText){
   printf("\033[1m%s\033[0m", zText);
 }
 #endif
 /*
 ** Get the argument to an --option.  Throw an error and die if no argument
 ** is available.
 */

@@ -3134,12 +3574,15 @@ int main(int argc, char **argv){

   char *zFirstCmd = 0;
   int i;
   int rc = 0;
   int warnInmemoryDb = 0;
 #if USE_SYSTEM_SQLITE+0!=1
   if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
     fprintf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
             sqlite3_sourceid(), SQLITE_SOURCE_ID);
     exit(1);
   }
 #endif
   Argv0 = argv[0];
   main_init(&data);
   stdin_is_interactive = isatty(0);

@@ -3228,10 +3671,16 @@ int main(int argc, char **argv){

   if( data.zDbFilename==0 ){
 #ifndef SQLITE_OMIT_MEMORYDB
     data.zDbFilename = ":memory:";
     warnInmemoryDb = argc==1;
 #else
     fprintf(stderr,"%s: Error: no database filename specified\n", Argv0);
     return 1;
 #endif
 #ifdef SQLITE_SHELL_DBNAME_PROC
     { extern void SQLITE_SHELL_DBNAME_PROC(const char**);
       SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
       warnInmemoryDb = 0; }
 #endif
   }
   /**** Begin pkgng patch losely based on fossil patch ****/
   {

@@ -3247,7 +3696,7 @@ int main(int argc, char **argv){

   ** to the sqlite command-line tool.
   */
   if( access(data.zDbFilename, 0)==0 ){
     open_db(&data);
     open_db(&data, 0);
   }
   /* Process the initialization file if there is one.  If no -init option

@@ -3293,6 +3742,8 @@ int main(int argc, char **argv){

       data.showHeader = 0;
     }else if( strcmp(z,"-echo")==0 ){
       data.echoOn = 1;
     }else if( strcmp(z,"-eqp")==0 ){
       data.autoEQP = 1;
     }else if( strcmp(z,"-stats")==0 ){
       data.statsOn = 1;
     }else if( strcmp(z,"-bail")==0 ){

@@ -3327,7 +3778,7 @@ int main(int argc, char **argv){

         rc = do_meta_command(z, &data);
         if( rc && bail_on_error ) return rc==2 ? 0 : rc;
       }else{
         open_db(&data);
         open_db(&data, 0);
         rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
         if( zErrMsg!=0 ){
           fprintf(stderr,"Error: %s\n", zErrMsg);

@@ -3351,7 +3802,7 @@ int main(int argc, char **argv){

       rc = do_meta_command(zFirstCmd, &data);
       if( rc==2 ) rc = 0;
     }else{
       open_db(&data);
       open_db(&data, 0);
       rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg);
       if( zErrMsg!=0 ){
         fprintf(stderr,"Error: %s\n", zErrMsg);

@@ -3370,10 +3821,15 @@ int main(int argc, char **argv){

       int nHistory;
       printf(
         "SQLite version %s %.19s\n" /*extra-version-info*/
         "Enter \".help\" for instructions\n"
         "Enter SQL statements terminated with a \";\"\n",
         "Enter \".help\" for usage hints.\n",
         sqlite3_libversion(), sqlite3_sourceid()
       );
       if( warnInmemoryDb ){
         printf("Connected to a ");
         printBold("transient in-memory database");
         printf(".\nUse \".open FILENAME\" to reopen on a "
                "persistent database.\n");
       }
       zHome = find_home_dir();
       if( zHome ){
         nHistory = strlen30(zHome) + 20;

@@ -3381,7 +3837,7 @@ int main(int argc, char **argv){

           sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
         }
       }
 #if defined(HAVE_READLINE) && HAVE_READLINE==1
 #if defined(HAVE_READLINE)
       if( zHistory ) read_history(zHistory);
 #endif
       rc = process_input(&data, 0);

@@ -3398,5 +3854,6 @@ int main(int argc, char **argv){

   if( data.db ){
     sqlite3_close(data.db);
   }
   sqlite3_free(data.zFreeOnClose);
   return rc;
 }

modified external/sqlite/sqlite3.c

@@ -1,6 +1,6 @@

 /******************************************************************************
 ** This file is an amalgamation of many separate C source files from SQLite
 ** version 3.8.1.  By combining all the individual C code files into this
 ** version 3.8.4.1.  By combining all the individual C code files into this
 ** single large file, the entire code can be compiled as a single translation
 ** unit.  This allows many compilers to do optimizations that would not be
 ** possible if the files were compiled separately.  Performance improvements

@@ -25,6 +25,93 @@

 #ifndef SQLITE_API
 # define SQLITE_API
 #endif
 /************** Begin file sqliteInt.h ***************************************/
 /*
 ** 2001 September 15
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 ** Internal interface definitions for SQLite.
 **
 */
 #ifndef _SQLITEINT_H_
 #define _SQLITEINT_H_
 /*
 ** These #defines should enable >2GB file support on POSIX if the
 ** underlying operating system supports it.  If the OS lacks
 ** large file support, or if the OS is windows, these should be no-ops.
 **
 ** Ticket #2739:  The _LARGEFILE_SOURCE macro must appear before any
 ** system #includes.  Hence, this block of code must be the very first
 ** code in all source files.
 **
 ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
 ** on the compiler command line.  This is necessary if you are compiling
 ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
 ** on an older machine (ex: Red Hat 6.0).  If you compile on Red Hat 7.2
 ** without this option, LFS is enable.  But LFS does not exist in the kernel
 ** in Red Hat 6.0, so the code won't work.  Hence, for maximum binary
 ** portability you should omit LFS.
 **
 ** The previous paragraph was written in 2005.  (This paragraph is written
 ** on 2008-11-28.) These days, all Linux kernels support large files, so
 ** you should probably leave LFS enabled.  But some embedded platforms might
 ** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
 **
 ** Similar is true for Mac OS X.  LFS is only supported on Mac OS X 9 and later.
 */
 #ifndef SQLITE_DISABLE_LFS
 # define _LARGE_FILE       1
 # ifndef _FILE_OFFSET_BITS
 #   define _FILE_OFFSET_BITS 64
 # endif
 # define _LARGEFILE_SOURCE 1
 #endif
 /*
 ** For MinGW, check to see if we can include the header file containing its
 ** version information, among other things.  Normally, this internal MinGW
 ** header file would [only] be included automatically by other MinGW header
 ** files; however, the contained version information is now required by this
 ** header file to work around binary compatibility issues (see below) and
 ** this is the only known way to reliably obtain it.  This entire #if block
 ** would be completely unnecessary if there was any other way of detecting
 ** MinGW via their preprocessor (e.g. if they customized their GCC to define
 ** some MinGW-specific macros).  When compiling for MinGW, either the
 ** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be
 ** defined; otherwise, detection of conditions specific to MinGW will be
 ** disabled.
 */
 #if defined(_HAVE_MINGW_H)
 # include "mingw.h"
 #elif defined(_HAVE__MINGW_H)
 # include "_mingw.h"
 #endif
 /*
 ** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T
 ** define is required to maintain binary compatibility with the MSVC runtime
 ** library in use (e.g. for Windows XP).
 */
 #if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \
     defined(_WIN32) && !defined(_WIN64) && \
     defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \
     defined(__MSVCRT__)
 # define _USE_32BIT_TIME_T
 #endif
 /* The public SQLite interface.  The _FILE_OFFSET_BITS macro must appear
 ** first in QNX.  Also, the _USE_32BIT_TIME_T macro must appear first for
 ** MinGW.
 */
 /************** Include sqlite3.h in the middle of sqliteInt.h ***************/
 /************** Begin file sqlite3.h *****************************************/
 /*
 ** 2001 September 15

@@ -135,9 +222,9 @@ extern "C" {

 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
 #define SQLITE_VERSION        "3.8.1"
 #define SQLITE_VERSION_NUMBER 3008001
 #define SQLITE_SOURCE_ID      "2013-10-17 12:57:35 c78be6d786c19073b3a6730dfe3fb1be54f5657a"
 #define SQLITE_VERSION        "3.8.4.1"
 #define SQLITE_VERSION_NUMBER 3008004
 #define SQLITE_SOURCE_ID      "2014-03-11 15:27:36 018d317b1257ce68a92908b05c9c7cf1494050d0"
 /*
 ** CAPI3REF: Run-Time Library Version Numbers

@@ -398,7 +485,7 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);

 ** <ul>
 ** <li> The application must insure that the 1st parameter to sqlite3_exec()
 **      is a valid and open [database connection].
 ** <li> The application must not close [database connection] specified by
 ** <li> The application must not close the [database connection] specified by
 **      the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
 ** <li> The application must not modify the SQL statement text passed into
 **      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.

@@ -475,7 +562,7 @@ SQLITE_API int sqlite3_exec(

 ** [sqlite3_extended_result_codes()] API.
 **
 ** Some of the available extended result codes are listed here.
 ** One may expect the number of extended result codes will be expand
 ** One may expect the number of extended result codes will increase
 ** over time.  Software that uses extended result codes should expect
 ** to see new result codes in future releases of SQLite.
 **

@@ -519,6 +606,7 @@ SQLITE_API int sqlite3_exec(

 #define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
 #define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
 #define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
 #define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
 #define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
 #define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
 #define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))

@@ -529,6 +617,7 @@ SQLITE_API int sqlite3_exec(

 #define SQLITE_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))
 #define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))
 #define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))
 #define SQLITE_CONSTRAINT_ROWID        (SQLITE_CONSTRAINT |(10<<8))
 #define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
 #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
 #define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))

@@ -585,7 +674,8 @@ SQLITE_API int sqlite3_exec(

 ** after reboot following a crash or power loss, the only bytes in a
 ** file that were written at the application level might have changed
 ** and that adjacent bytes, even bytes within the same sector are
 ** guaranteed to be unchanged.
 ** guaranteed to be unchanged.  The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
 ** flag indicate that a file cannot be deleted when open.
 */
 #define SQLITE_IOCAP_ATOMIC                 0x00000001
 #define SQLITE_IOCAP_ATOMIC512              0x00000002

@@ -816,15 +906,29 @@ struct sqlite3_io_methods {

 ** additional information.
 **
 ** <li>[[SQLITE_FCNTL_SYNC_OMITTED]]
 ** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by
 ** SQLite and sent to all VFSes in place of a call to the xSync method
 ** when the database connection has [PRAGMA synchronous] set to OFF.)^
 ** Some specialized VFSes need this signal in order to operate correctly
 ** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most
 ** VFSes do not need this signal and should silently ignore this opcode.
 ** Applications should not call [sqlite3_file_control()] with this
 ** opcode as doing so may disrupt the operation of the specialized VFSes
 ** that do require it.
 ** No longer in use.
 **
 ** <li>[[SQLITE_FCNTL_SYNC]]
 ** The [SQLITE_FCNTL_SYNC] opcode is generated internally by SQLite and
 ** sent to the VFS immediately before the xSync method is invoked on a
 ** database file descriptor. Or, if the xSync method is not invoked
 ** because the user has configured SQLite with
 ** [PRAGMA synchronous | PRAGMA synchronous=OFF] it is invoked in place
 ** of the xSync method. In most cases, the pointer argument passed with
 ** this file-control is NULL. However, if the database file is being synced
 ** as part of a multi-database commit, the argument points to a nul-terminated
 ** string containing the transactions master-journal file name. VFSes that
 ** do not need this signal should silently ignore this opcode. Applications
 ** should not call [sqlite3_file_control()] with this opcode as doing so may
 ** disrupt the operation of the specialized VFSes that do require it.
 **
 ** <li>[[SQLITE_FCNTL_COMMIT_PHASETWO]]
 ** The [SQLITE_FCNTL_COMMIT_PHASETWO] opcode is generated internally by SQLite
 ** and sent to the VFS after a transaction has been committed immediately
 ** but before the database is unlocked. VFSes that do not need this signal
 ** should silently ignore this opcode. Applications should not call
 ** [sqlite3_file_control()] with this opcode as doing so may disrupt the
 ** operation of the specialized VFSes that do require it.
 **
 ** <li>[[SQLITE_FCNTL_WIN32_AV_RETRY]]
 ** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic

@@ -940,6 +1044,20 @@ struct sqlite3_io_methods {

 ** can be queried by passing in a pointer to a negative number.  This
 ** file-control is used internally to implement [PRAGMA mmap_size].
 **
 ** <li>[[SQLITE_FCNTL_TRACE]]
 ** The [SQLITE_FCNTL_TRACE] file control provides advisory information
 ** to the VFS about what the higher layers of the SQLite stack are doing.
 ** This file control is used by some VFS activity tracing [shims].
 ** The argument is a zero-terminated string.  Higher layers in the
 ** SQLite stack may generate instances of this file control if
 ** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled.
 **
 ** <li>[[SQLITE_FCNTL_HAS_MOVED]]
 ** The [SQLITE_FCNTL_HAS_MOVED] file control interprets its argument as a
 ** pointer to an integer and it writes a boolean into that integer depending
 ** on whether or not the file has been renamed, moved, or deleted since it
 ** was first opened.
 **
 ** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1

@@ -959,6 +1077,10 @@ struct sqlite3_io_methods {

 #define SQLITE_FCNTL_BUSYHANDLER            15
 #define SQLITE_FCNTL_TEMPFILENAME           16
 #define SQLITE_FCNTL_MMAP_SIZE              18
 #define SQLITE_FCNTL_TRACE                  19
 #define SQLITE_FCNTL_HAS_MOVED              20
 #define SQLITE_FCNTL_SYNC                   21
 #define SQLITE_FCNTL_COMMIT_PHASETWO        22
 /*
 ** CAPI3REF: Mutex Handle

@@ -1403,7 +1525,7 @@ SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...);

 ** or [sqlite3_realloc()] first calls xRoundup.  If xRoundup returns 0,
 ** that causes the corresponding memory allocation to fail.
 **
 ** The xInit method initializes the memory allocator.  (For example,
 ** The xInit method initializes the memory allocator.  For example,
 ** it might allocate any require mutexes or initialize internal data
 ** structures.  The xShutdown method is invoked (indirectly) by
 ** [sqlite3_shutdown()] and should deallocate any resources acquired

@@ -1705,6 +1827,13 @@ struct sqlite3_mem_methods {

 ** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^
 ** ^If either argument to this option is negative, then that argument is
 ** changed to its compile-time default.
 **
 ** [[SQLITE_CONFIG_WIN32_HEAPSIZE]]
 ** <dt>SQLITE_CONFIG_WIN32_HEAPSIZE
 ** <dd>^This option is only available if SQLite is compiled for Windows
 ** with the [SQLITE_WIN32_MALLOC] pre-processor macro defined.
 ** SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
 ** that specifies the maximum size of the created heap.
 ** </dl>
 */
 #define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */

@@ -1729,6 +1858,7 @@ struct sqlite3_mem_methods {

 #define SQLITE_CONFIG_COVERING_INDEX_SCAN 20  /* int */
 #define SQLITE_CONFIG_SQLLOG       21  /* xSqllog, void* */
 #define SQLITE_CONFIG_MMAP_SIZE    22  /* sqlite3_int64, sqlite3_int64 */
 #define SQLITE_CONFIG_WIN32_HEAPSIZE      23  /* int nByte */
 /*
 ** CAPI3REF: Database Connection Configuration Options

@@ -1805,19 +1935,21 @@ SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);

 /*
 ** CAPI3REF: Last Insert Rowid
 **
 ** ^Each entry in an SQLite table has a unique 64-bit signed
 ** ^Each entry in most SQLite tables (except for [WITHOUT ROWID] tables)
 ** has a unique 64-bit signed
 ** integer key called the [ROWID | "rowid"]. ^The rowid is always available
 ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
 ** names are not also used by explicitly declared columns. ^If
 ** the table has a column of type [INTEGER PRIMARY KEY] then that column
 ** is another alias for the rowid.
 **
 ** ^This routine returns the [rowid] of the most recent
 ** successful [INSERT] into the database from the [database connection]
 ** in the first argument.  ^As of SQLite version 3.7.7, this routines
 ** records the last insert rowid of both ordinary tables and [virtual tables].
 ** ^If no successful [INSERT]s
 ** have ever occurred on that database connection, zero is returned.
 ** ^The sqlite3_last_insert_rowid(D) interface returns the [rowid] of the
 ** most recent successful [INSERT] into a rowid table or [virtual table]
 ** on database connection D.
 ** ^Inserts into [WITHOUT ROWID] tables are not recorded.
 ** ^If no successful [INSERT]s into rowid tables
 ** have ever occurred on the database connection D,
 ** then sqlite3_last_insert_rowid(D) returns zero.
 **
 ** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
 ** method, then this routine will return the [rowid] of the inserted

@@ -2383,11 +2515,13 @@ SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);

 ** applications to access the same PRNG for other purposes.
 **
 ** ^A call to this routine stores N bytes of randomness into buffer P.
 ** ^If N is less than one, then P can be a NULL pointer.
 **
 ** ^The first time this routine is invoked (either internally or by
 ** the application) the PRNG is seeded using randomness obtained
 ** from the xRandomness method of the default [sqlite3_vfs] object.
 ** ^On all subsequent invocations, the pseudo-randomness is generated
 ** ^If this routine has not been previously called or if the previous
 ** call had N less than one, then the PRNG is seeded using randomness
 ** obtained from the xRandomness method of the default [sqlite3_vfs] object.
 ** ^If the previous call to this routine had an N of 1 or more then
 ** the pseudo-randomness is generated
 ** internally and without recourse to the [sqlite3_vfs] xRandomness
 ** method.
 */

@@ -2547,6 +2681,7 @@ SQLITE_API int sqlite3_set_authorizer(

 #define SQLITE_FUNCTION             31   /* NULL            Function Name   */
 #define SQLITE_SAVEPOINT            32   /* Operation       Savepoint Name  */
 #define SQLITE_COPY                  0   /* No longer used */
 #define SQLITE_RECURSIVE            33   /* NULL            NULL            */
 /*
 ** CAPI3REF: Tracing And Profiling Functions

@@ -3127,7 +3262,6 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);

 ** choice of query plan if the parameter is the left-hand side of a [LIKE]
 ** or [GLOB] operator or if the parameter is compared to an indexed column
 ** and the [SQLITE_ENABLE_STAT3] compile-time option is enabled.
 ** the
 ** </li>
 ** </ol>
 */

@@ -3789,19 +3923,19 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);

 **
 ** <tr><td>  NULL    <td> INTEGER   <td> Result is 0
 ** <tr><td>  NULL    <td>  FLOAT    <td> Result is 0.0
 ** <tr><td>  NULL    <td>   TEXT    <td> Result is NULL pointer
 ** <tr><td>  NULL    <td>   BLOB    <td> Result is NULL pointer
 ** <tr><td>  NULL    <td>   TEXT    <td> Result is a NULL pointer
 ** <tr><td>  NULL    <td>   BLOB    <td> Result is a NULL pointer
 ** <tr><td> INTEGER  <td>  FLOAT    <td> Convert from integer to float
 ** <tr><td> INTEGER  <td>   TEXT    <td> ASCII rendering of the integer
 ** <tr><td> INTEGER  <td>   BLOB    <td> Same as INTEGER->TEXT
 ** <tr><td>  FLOAT   <td> INTEGER   <td> Convert from float to integer
 ** <tr><td>  FLOAT   <td> INTEGER   <td> [CAST] to INTEGER
 ** <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
 ** <tr><td>  FLOAT   <td>   BLOB    <td> Same as FLOAT->TEXT
 ** <tr><td>  TEXT    <td> INTEGER   <td> Use atoi()
 ** <tr><td>  TEXT    <td>  FLOAT    <td> Use atof()
 ** <tr><td>  FLOAT   <td>   BLOB    <td> [CAST] to BLOB
 ** <tr><td>  TEXT    <td> INTEGER   <td> [CAST] to INTEGER
 ** <tr><td>  TEXT    <td>  FLOAT    <td> [CAST] to REAL
 ** <tr><td>  TEXT    <td>   BLOB    <td> No change
 ** <tr><td>  BLOB    <td> INTEGER   <td> Convert to TEXT then use atoi()
 ** <tr><td>  BLOB    <td>  FLOAT    <td> Convert to TEXT then use atof()
 ** <tr><td>  BLOB    <td> INTEGER   <td> [CAST] to INTEGER
 ** <tr><td>  BLOB    <td>  FLOAT    <td> [CAST] to REAL
 ** <tr><td>  BLOB    <td>   TEXT    <td> Add a zero terminator if needed
 ** </table>
 ** </blockquote>)^

@@ -3857,7 +3991,7 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);

 ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
 ** [sqlite3_finalize()] is called.  ^The memory space used to hold strings
 ** and BLOBs is freed automatically.  Do <b>not</b> pass the pointers returned
 ** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
 ** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
 ** [sqlite3_free()].
 **
 ** ^(If a memory allocation error occurs during the evaluation of any

@@ -3966,15 +4100,24 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);

 **
 ** ^The fourth parameter, eTextRep, specifies what
 ** [SQLITE_UTF8 | text encoding] this SQL function prefers for
 ** its parameters.  Every SQL function implementation must be able to work
 ** with UTF-8, UTF-16le, or UTF-16be.  But some implementations may be
 ** more efficient with one encoding than another.  ^An application may
 ** invoke sqlite3_create_function() or sqlite3_create_function16() multiple
 ** times with the same function but with different values of eTextRep.
 ** its parameters.  The application should set this parameter to
 ** [SQLITE_UTF16LE] if the function implementation invokes
 ** [sqlite3_value_text16le()] on an input, or [SQLITE_UTF16BE] if the
 ** implementation invokes [sqlite3_value_text16be()] on an input, or
 ** [SQLITE_UTF16] if [sqlite3_value_text16()] is used, or [SQLITE_UTF8]
 ** otherwise.  ^The same SQL function may be registered multiple times using
 ** different preferred text encodings, with different implementations for
 ** each encoding.
 ** ^When multiple implementations of the same function are available, SQLite
 ** will pick the one that involves the least amount of data conversion.
 ** If there is only a single implementation which does not care what text
 ** encoding is used, then the fourth argument should be [SQLITE_ANY].
 **
 ** ^The fourth parameter may optionally be ORed with [SQLITE_DETERMINISTIC]
 ** to signal that the function will always return the same result given
 ** the same inputs within a single SQL statement.  Most SQL functions are
 ** deterministic.  The built-in [random()] SQL function is an example of a
 ** function that is not deterministic.  The SQLite query planner is able to
 ** perform additional optimizations on deterministic functions, so use
 ** of the [SQLITE_DETERMINISTIC] flag is recommended where possible.
 **
 ** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
 ** function can gain access to this pointer using [sqlite3_user_data()].)^

@@ -4060,10 +4203,20 @@ SQLITE_API int sqlite3_create_function_v2(

 #define SQLITE_UTF16LE        2
 #define SQLITE_UTF16BE        3
 #define SQLITE_UTF16          4    /* Use native byte order */
 #define SQLITE_ANY            5    /* sqlite3_create_function only */
 #define SQLITE_ANY            5    /* Deprecated */
 #define SQLITE_UTF16_ALIGNED  8    /* sqlite3_create_collation only */
 /*
 ** CAPI3REF: Function Flags
 **
 ** These constants may be ORed together with the
 ** [SQLITE_UTF8 | preferred text encoding] as the fourth argument
 ** to [sqlite3_create_function()], [sqlite3_create_function16()], or
 ** [sqlite3_create_function_v2()].
 */
 #define SQLITE_DETERMINISTIC    0x800
 /*
 ** CAPI3REF: Deprecated Functions
 ** DEPRECATED
 **

@@ -4834,12 +4987,13 @@ SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);

 **
 ** ^The sqlite3_update_hook() interface registers a callback function
 ** with the [database connection] identified by the first argument
 ** to be invoked whenever a row is updated, inserted or deleted.
 ** to be invoked whenever a row is updated, inserted or deleted in
 ** a rowid table.
 ** ^Any callback set by a previous call to this function
 ** for the same database connection is overridden.
 **
 ** ^The second argument is a pointer to the function to invoke when a
 ** row is updated, inserted or deleted.
 ** row is updated, inserted or deleted in a rowid table.
 ** ^The first argument to the callback is a copy of the third argument
 ** to sqlite3_update_hook().
 ** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE],

@@ -4852,6 +5006,7 @@ SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);

 **
 ** ^(The update hook is not invoked when internal system tables are
 ** modified (i.e. sqlite_master and sqlite_sequence).)^
 ** ^The update hook is not invoked when [WITHOUT ROWID] tables are modified.
 **
 ** ^In the current implementation, the update hook
 ** is not invoked when duplication rows are deleted because of an

@@ -4933,8 +5088,8 @@ SQLITE_API int sqlite3_release_memory(int);

 **
 ** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap
 ** memory as possible from database connection D. Unlike the
 ** [sqlite3_release_memory()] interface, this interface is effect even
 ** when then [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
 ** [sqlite3_release_memory()] interface, this interface is in effect even
 ** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
 ** omitted.
 **
 ** See also: [sqlite3_release_memory()]

@@ -5309,10 +5464,22 @@ struct sqlite3_module {

 ** the correct order to satisfy the ORDER BY clause so that no separate
 ** sorting step is required.
 **
 ** ^The estimatedCost value is an estimate of the cost of doing the
 ** particular lookup.  A full scan of a table with N entries should have
 ** a cost of N.  A binary search of a table of N entries should have a
 ** cost of approximately log(N).
 ** ^The estimatedCost value is an estimate of the cost of a particular
 ** strategy. A cost of N indicates that the cost of the strategy is similar
 ** to a linear scan of an SQLite table with N rows. A cost of log(N)
 ** indicates that the expense of the operation is similar to that of a
 ** binary search on a unique indexed field of an SQLite table with N rows.
 **
 ** ^The estimatedRows value is an estimate of the number of rows that
 ** will be returned by the strategy.
 **
 ** IMPORTANT: The estimatedRows field was added to the sqlite3_index_info
 ** structure for SQLite version 3.8.2. If a virtual table extension is
 ** used with an SQLite version earlier than 3.8.2, the results of attempting
 ** to read or write the estimatedRows field are undefined (but are likely
 ** to included crashing the application). The estimatedRows field should
 ** therefore only be used if [sqlite3_libversion_number()] returns a
 ** value greater than or equal to 3008002.
 */
 struct sqlite3_index_info {
   /* Inputs */

@@ -5337,7 +5504,9 @@ struct sqlite3_index_info {

   char *idxStr;              /* String, possibly obtained from sqlite3_malloc */
   int needToFreeIdxStr;      /* Free idxStr using sqlite3_free() if true */
   int orderByConsumed;       /* True if output is already ordered */
   double estimatedCost;      /* Estimated cost of using this index */
   double estimatedCost;           /* Estimated cost of using this index */
   /* Fields below are only available in SQLite 3.8.2 and later */
   sqlite3_int64 estimatedRows;    /* Estimated number of rows returned */
 };
 /*

@@ -5541,6 +5710,9 @@ typedef struct sqlite3_blob sqlite3_blob;

 ** interface.  Use the [UPDATE] SQL command to change the size of a
 ** blob.
 **
 ** ^The [sqlite3_blob_open()] interface will fail for a [WITHOUT ROWID]
 ** table.  Incremental BLOB I/O is not possible on [WITHOUT ROWID] tables.
 **
 ** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces
 ** and the built-in [zeroblob] SQL function can be used, if desired,
 ** to create an empty, zero-filled blob in which to read or write using

@@ -6064,7 +6236,9 @@ SQLITE_API int sqlite3_test_control(int op, ...);

 #define SQLITE_TESTCTRL_SCRATCHMALLOC           17
 #define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
 #define SQLITE_TESTCTRL_EXPLAIN_STMT            19
 #define SQLITE_TESTCTRL_LAST                    19
 #define SQLITE_TESTCTRL_NEVER_CORRUPT           20
 #define SQLITE_TESTCTRL_VDBE_COVERAGE           21
 #define SQLITE_TESTCTRL_LAST                    21
 /*
 ** CAPI3REF: SQLite Runtime Status

@@ -7327,50 +7501,7 @@ struct sqlite3_rtree_geometry {

 /************** End of sqlite3.h *********************************************/
 /************** Begin file sqliteInt.h ***************************************/
 /*
 ** 2001 September 15
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 ** Internal interface definitions for SQLite.
 **
 */
 #ifndef _SQLITEINT_H_
 #define _SQLITEINT_H_
 /*
 ** These #defines should enable >2GB file support on POSIX if the
 ** underlying operating system supports it.  If the OS lacks
 ** large file support, or if the OS is windows, these should be no-ops.
 **
 ** Ticket #2739:  The _LARGEFILE_SOURCE macro must appear before any
 ** system #includes.  Hence, this block of code must be the very first
 ** code in all source files.
 **
 ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
 ** on the compiler command line.  This is necessary if you are compiling
 ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
 ** on an older machine (ex: Red Hat 6.0).  If you compile on Red Hat 7.2
 ** without this option, LFS is enable.  But LFS does not exist in the kernel
 ** in Red Hat 6.0, so the code won't work.  Hence, for maximum binary
 ** portability you should omit LFS.
 **
 ** Similar is true for Mac OS X.  LFS is only supported on Mac OS X 9 and later.
 */
 #ifndef SQLITE_DISABLE_LFS
 # define _LARGE_FILE       1
 # ifndef _FILE_OFFSET_BITS
 #   define _FILE_OFFSET_BITS 64
 # endif
 # define _LARGEFILE_SOURCE 1
 #endif
 /************** Continuing where we left off in sqliteInt.h ******************/
 /*
 ** Include the configuration header output by 'configure' if we're using the

@@ -7759,6 +7890,13 @@ struct sqlite3_rtree_geometry {

 #endif
 /*
 ** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on.
 */
 #if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG)
 # define SQLITE_ENABLE_EXPLAIN_COMMENTS 1
 #endif
 /*
 ** The testcase() macro is used to aid in coverage testing.  When
 ** doing coverage testing, the condition inside the argument to
 ** testcase() must be evaluated both true and false in order to

@@ -7950,163 +8088,165 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);

 /************** Continuing where we left off in sqliteInt.h ******************/
 /************** Include parse.h in the middle of sqliteInt.h *****************/
 /************** Begin file parse.h *******************************************/
 #define TK_SEMI                            1
 #define TK_EXPLAIN                         2
 #define TK_QUERY                           3
 #define TK_PLAN                            4
 #define TK_BEGIN                           5
 #define TK_TRANSACTION                     6
 #define TK_DEFERRED                        7
 #define TK_IMMEDIATE                       8
 #define TK_EXCLUSIVE                       9
 #define TK_COMMIT                         10
 #define TK_END                            11
 #define TK_ROLLBACK                       12
 #define TK_SAVEPOINT                      13
 #define TK_RELEASE                        14
 #define TK_TO                             15
 #define TK_TABLE                          16
 #define TK_CREATE                         17
 #define TK_IF                             18
 #define TK_NOT                            19
 #define TK_EXISTS                         20
 #define TK_TEMP                           21
 #define TK_LP                             22
 #define TK_RP                             23
 #define TK_AS                             24
 #define TK_COMMA                          25
 #define TK_ID                             26
 #define TK_INDEXED                        27
 #define TK_ABORT                          28
 #define TK_ACTION                         29
 #define TK_AFTER                          30
 #define TK_ANALYZE                        31
 #define TK_ASC                            32
 #define TK_ATTACH                         33
 #define TK_BEFORE                         34
 #define TK_BY                             35
 #define TK_CASCADE                        36
 #define TK_CAST                           37
 #define TK_COLUMNKW                       38
 #define TK_CONFLICT                       39
 #define TK_DATABASE                       40
 #define TK_DESC                           41
 #define TK_DETACH                         42
 #define TK_EACH                           43
 #define TK_FAIL                           44
 #define TK_FOR                            45
 #define TK_IGNORE                         46
 #define TK_INITIALLY                      47
 #define TK_INSTEAD                        48
 #define TK_LIKE_KW                        49
 #define TK_MATCH                          50
 #define TK_NO                             51
 #define TK_KEY                            52
 #define TK_OF                             53
 #define TK_OFFSET                         54
 #define TK_PRAGMA                         55
 #define TK_RAISE                          56
 #define TK_REPLACE                        57
 #define TK_RESTRICT                       58
 #define TK_ROW                            59
 #define TK_TRIGGER                        60
 #define TK_VACUUM                         61
 #define TK_VIEW                           62
 #define TK_VIRTUAL                        63
 #define TK_REINDEX                        64
 #define TK_RENAME                         65
 #define TK_CTIME_KW                       66
 #define TK_ANY                            67
 #define TK_OR                             68
 #define TK_AND                            69
 #define TK_IS                             70
 #define TK_BETWEEN                        71
 #define TK_IN                             72
 #define TK_ISNULL                         73
 #define TK_NOTNULL                        74
 #define TK_NE                             75
 #define TK_EQ                             76
 #define TK_GT                             77
 #define TK_LE                             78
 #define TK_LT                             79
 #define TK_GE                             80
 #define TK_ESCAPE                         81
 #define TK_BITAND                         82
 #define TK_BITOR                          83
 #define TK_LSHIFT                         84
 #define TK_RSHIFT                         85
 #define TK_PLUS                           86
 #define TK_MINUS                          87
 #define TK_STAR                           88
 #define TK_SLASH                          89
 #define TK_REM                            90
 #define TK_CONCAT                         91
 #define TK_COLLATE                        92
 #define TK_BITNOT                         93
 #define TK_STRING                         94
 #define TK_JOIN_KW                        95
 #define TK_CONSTRAINT                     96
 #define TK_DEFAULT                        97
 #define TK_NULL                           98
 #define TK_PRIMARY                        99
 #define TK_UNIQUE                         100
 #define TK_CHECK                          101
 #define TK_REFERENCES                     102
 #define TK_AUTOINCR                       103
 #define TK_ON                             104
 #define TK_INSERT                         105
 #define TK_DELETE                         106
 #define TK_UPDATE                         107
 #define TK_SET                            108
 #define TK_DEFERRABLE                     109
 #define TK_FOREIGN                        110
 #define TK_DROP                           111
 #define TK_UNION                          112
 #define TK_ALL                            113
 #define TK_EXCEPT                         114
 #define TK_INTERSECT                      115
 #define TK_SELECT                         116
 #define TK_DISTINCT                       117
 #define TK_DOT                            118
 #define TK_FROM                           119
 #define TK_JOIN                           120
 #define TK_USING                          121
 #define TK_ORDER                          122
 #define TK_GROUP                          123
 #define TK_HAVING                         124
 #define TK_LIMIT                          125
 #define TK_WHERE                          126
 #define TK_INTO                           127
 #define TK_VALUES                         128
 #define TK_INTEGER                        129
 #define TK_FLOAT                          130
 #define TK_BLOB                           131
 #define TK_REGISTER                       132
 #define TK_VARIABLE                       133
 #define TK_CASE                           134
 #define TK_WHEN                           135
 #define TK_THEN                           136
 #define TK_ELSE                           137
 #define TK_INDEX                          138
 #define TK_ALTER                          139
 #define TK_ADD                            140
 #define TK_TO_TEXT                        141
 #define TK_TO_BLOB                        142
 #define TK_TO_NUMERIC                     143
 #define TK_TO_INT                         144
 #define TK_TO_REAL                        145
 #define TK_ISNOT                          146
 #define TK_END_OF_FILE                    147
 #define TK_ILLEGAL                        148
 #define TK_SPACE                          149
 #define TK_UNCLOSED_STRING                150
 #define TK_FUNCTION                       151
 #define TK_COLUMN                         152
 #define TK_AGG_FUNCTION                   153
 #define TK_AGG_COLUMN                     154
 #define TK_CONST_FUNC                     155
 #define TK_UMINUS                         156
 #define TK_UPLUS                          157
 #define TK_SEMI                             1
 #define TK_EXPLAIN                          2
 #define TK_QUERY                            3
 #define TK_PLAN                             4
 #define TK_BEGIN                            5
 #define TK_TRANSACTION                      6
 #define TK_DEFERRED                         7
 #define TK_IMMEDIATE                        8
 #define TK_EXCLUSIVE                        9
 #define TK_COMMIT                          10
 #define TK_END                             11
 #define TK_ROLLBACK                        12
 #define TK_SAVEPOINT                       13
 #define TK_RELEASE                         14
 #define TK_TO                              15
 #define TK_TABLE                           16
 #define TK_CREATE                          17
 #define TK_IF                              18
 #define TK_NOT                             19
 #define TK_EXISTS                          20
 #define TK_TEMP                            21
 #define TK_LP                              22
 #define TK_RP                              23
 #define TK_AS                              24
 #define TK_WITHOUT                         25
 #define TK_COMMA                           26
 #define TK_ID                              27
 #define TK_INDEXED                         28
 #define TK_ABORT                           29
 #define TK_ACTION                          30
 #define TK_AFTER                           31
 #define TK_ANALYZE                         32
 #define TK_ASC                             33
 #define TK_ATTACH                          34
 #define TK_BEFORE                          35
 #define TK_BY                              36
 #define TK_CASCADE                         37
 #define TK_CAST                            38
 #define TK_COLUMNKW                        39
 #define TK_CONFLICT                        40
 #define TK_DATABASE                        41
 #define TK_DESC                            42
 #define TK_DETACH                          43
 #define TK_EACH                            44
 #define TK_FAIL                            45
 #define TK_FOR                             46
 #define TK_IGNORE                          47
 #define TK_INITIALLY                       48
 #define TK_INSTEAD                         49
 #define TK_LIKE_KW                         50
 #define TK_MATCH                           51
 #define TK_NO                              52
 #define TK_KEY                             53
 #define TK_OF                              54
 #define TK_OFFSET                          55
 #define TK_PRAGMA                          56
 #define TK_RAISE                           57
 #define TK_RECURSIVE                       58
 #define TK_REPLACE                         59
 #define TK_RESTRICT                        60
 #define TK_ROW                             61
 #define TK_TRIGGER                         62
 #define TK_VACUUM                          63
 #define TK_VIEW                            64
 #define TK_VIRTUAL                         65
 #define TK_WITH                            66
 #define TK_REINDEX                         67
 #define TK_RENAME                          68
 #define TK_CTIME_KW                        69
 #define TK_ANY                             70
 #define TK_OR                              71
 #define TK_AND                             72
 #define TK_IS                              73
 #define TK_BETWEEN                         74
 #define TK_IN                              75
 #define TK_ISNULL                          76
 #define TK_NOTNULL                         77
 #define TK_NE                              78
 #define TK_EQ                              79
 #define TK_GT                              80
 #define TK_LE                              81
 #define TK_LT                              82
 #define TK_GE                              83
 #define TK_ESCAPE                          84
 #define TK_BITAND                          85
 #define TK_BITOR                           86
 #define TK_LSHIFT                          87
 #define TK_RSHIFT                          88
 #define TK_PLUS                            89
 #define TK_MINUS                           90
 #define TK_STAR                            91
 #define TK_SLASH                           92
 #define TK_REM                             93
 #define TK_CONCAT                          94
 #define TK_COLLATE                         95
 #define TK_BITNOT                          96
 #define TK_STRING                          97
 #define TK_JOIN_KW                         98
 #define TK_CONSTRAINT                      99
 #define TK_DEFAULT                        100
 #define TK_NULL                           101
 #define TK_PRIMARY                        102
 #define TK_UNIQUE                         103
 #define TK_CHECK                          104
 #define TK_REFERENCES                     105
 #define TK_AUTOINCR                       106
 #define TK_ON                             107
 #define TK_INSERT                         108
 #define TK_DELETE                         109
 #define TK_UPDATE                         110
 #define TK_SET                            111
 #define TK_DEFERRABLE                     112
 #define TK_FOREIGN                        113
 #define TK_DROP                           114
 #define TK_UNION                          115
 #define TK_ALL                            116
 #define TK_EXCEPT                         117
 #define TK_INTERSECT                      118
 #define TK_SELECT                         119
 #define TK_VALUES                         120
 #define TK_DISTINCT                       121
 #define TK_DOT                            122
 #define TK_FROM                           123
 #define TK_JOIN                           124
 #define TK_USING                          125
 #define TK_ORDER                          126
 #define TK_GROUP                          127
 #define TK_HAVING                         128
 #define TK_LIMIT                          129
 #define TK_WHERE                          130
 #define TK_INTO                           131
 #define TK_INTEGER                        132
 #define TK_FLOAT                          133
 #define TK_BLOB                           134
 #define TK_VARIABLE                       135
 #define TK_CASE                           136
 #define TK_WHEN                           137
 #define TK_THEN                           138
 #define TK_ELSE                           139
 #define TK_INDEX                          140
 #define TK_ALTER                          141
 #define TK_ADD                            142
 #define TK_TO_TEXT                        143
 #define TK_TO_BLOB                        144
 #define TK_TO_NUMERIC                     145
 #define TK_TO_INT                         146
 #define TK_TO_REAL                        147
 #define TK_ISNOT                          148
 #define TK_END_OF_FILE                    149
 #define TK_ILLEGAL                        150
 #define TK_SPACE                          151
 #define TK_UNCLOSED_STRING                152
 #define TK_FUNCTION                       153
 #define TK_COLUMN                         154
 #define TK_AGG_FUNCTION                   155
 #define TK_AGG_COLUMN                     156
 #define TK_UMINUS                         157
 #define TK_UPLUS                          158
 #define TK_REGISTER                       159
 /************** End of parse.h ***********************************************/
 /************** Continuing where we left off in sqliteInt.h ******************/

@@ -8537,6 +8677,7 @@ typedef struct LookasideSlot LookasideSlot;

 typedef struct Module Module;
 typedef struct NameContext NameContext;
 typedef struct Parse Parse;
 typedef struct PrintfArguments PrintfArguments;
 typedef struct RowSet RowSet;
 typedef struct Savepoint Savepoint;
 typedef struct Select Select;

@@ -8554,6 +8695,7 @@ typedef struct VTable VTable;

 typedef struct VtabCtx VtabCtx;
 typedef struct Walker Walker;
 typedef struct WhereInfo WhereInfo;
 typedef struct With With;
 /*
 ** Defer sourcing vdbe.h and btree.h until after the "u8" and

@@ -8742,12 +8884,10 @@ SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor*);

 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int *pRes);
 SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor*, i64 *pSize);
 SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt);
 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt);
 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, u32 *pAmt);
 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, u32 *pAmt);
 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize);
 SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor*, sqlite3_int64);
 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor*);
 SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*);
 SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*);

@@ -8883,13 +9023,16 @@ struct VdbeOp {

     SubProgram *pProgram;  /* Used when p4type is P4_SUBPROGRAM */
     int (*xAdvance)(BtCursor *, int *);
   } p4;
 #ifdef SQLITE_DEBUG
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
   char *zComment;          /* Comment to improve readability */
 #endif
 #ifdef VDBE_PROFILE
   int cnt;                 /* Number of times this instruction was executed */
   u32 cnt;                 /* Number of times this instruction was executed */
   u64 cycles;              /* Total time spent executing this instruction */
 #endif
 #ifdef SQLITE_VDBE_COVERAGE
   int iSrcLine;            /* Source-code line that generated this opcode */
 #endif
 };
 typedef struct VdbeOp VdbeOp;

@@ -8939,15 +9082,11 @@ typedef struct VdbeOpList VdbeOpList;

 #define P4_SUBPROGRAM  (-18) /* P4 is a pointer to a SubProgram structure */
 #define P4_ADVANCE  (-19) /* P4 is a pointer to BtreeNext() or BtreePrev() */
 /* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure
 ** is made.  That copy is freed when the Vdbe is finalized.  But if the
 ** argument is P4_KEYINFO_HANDOFF, the passed in pointer is used.  It still
 ** gets freed when the Vdbe is finalized so it still should be obtained
 ** from a single sqliteMalloc().  But no copy is made and the calling
 ** function should *not* try to free the KeyInfo.
 */
 #define P4_KEYINFO_HANDOFF (-16)
 #define P4_KEYINFO_STATIC  (-17)
 /* Error message codes for OP_Halt */
 #define P5_ConstraintNotNull 1
 #define P5_ConstraintUnique  2
 #define P5_ConstraintCheck   3
 #define P5_ConstraintFK      4
 /*
 ** The Vdbe.aColName array contains 5n Mem structures, where n is the

@@ -8984,156 +9123,162 @@ typedef struct VdbeOpList VdbeOpList;

 /************** Begin file opcodes.h *****************************************/
 /* Automatically generated.  Do not edit */
 /* See the mkopcodeh.awk script for details */
 #define OP_Function                             1
 #define OP_Savepoint                            2
 #define OP_AutoCommit                           3
 #define OP_Transaction                          4
 #define OP_SorterNext                           5
 #define OP_Prev                                 6
 #define OP_Next                                 7
 #define OP_AggStep                              8
 #define OP_Checkpoint                           9
 #define OP_JournalMode                         10
 #define OP_Vacuum                              11
 #define OP_VFilter                             12
 #define OP_VUpdate                             13
 #define OP_Goto                                14
 #define OP_Gosub                               15
 #define OP_Return                              16
 #define OP_Yield                               17
 #define OP_HaltIfNull                          18
 #define OP_Not                                 19   /* same as TK_NOT      */
 #define OP_Halt                                20
 #define OP_Integer                             21
 #define OP_Int64                               22
 #define OP_String                              23
 #define OP_Null                                24
 #define OP_Blob                                25
 #define OP_Variable                            26
 #define OP_Move                                27
 #define OP_Copy                                28
 #define OP_SCopy                               29
 #define OP_ResultRow                           30
 #define OP_CollSeq                             31
 #define OP_AddImm                              32
 #define OP_MustBeInt                           33
 #define OP_RealAffinity                        34
 #define OP_Permutation                         35
 #define OP_Compare                             36
 #define OP_Jump                                37
 #define OP_Once                                38
 #define OP_If                                  39
 #define OP_IfNot                               40
 #define OP_Column                              41
 #define OP_Affinity                            42
 #define OP_MakeRecord                          43
 #define OP_Count                               44
 #define OP_ReadCookie                          45
 #define OP_SetCookie                           46
 #define OP_VerifyCookie                        47
 #define OP_OpenRead                            48
 #define OP_OpenWrite                           49
 #define OP_OpenAutoindex                       50
 #define OP_OpenEphemeral                       51
 #define OP_SorterOpen                          52
 #define OP_OpenPseudo                          53
 #define OP_Close                               54
 #define OP_SeekLt                              55
 #define OP_SeekLe                              56
 #define OP_SeekGe                              57
 #define OP_SeekGt                              58
 #define OP_Seek                                59
 #define OP_NotFound                            60
 #define OP_Found                               61
 #define OP_IsUnique                            62
 #define OP_NotExists                           63
 #define OP_Sequence                            64
 #define OP_NewRowid                            65
 #define OP_Insert                              66
 #define OP_InsertInt                           67
 #define OP_Or                                  68   /* same as TK_OR       */
 #define OP_And                                 69   /* same as TK_AND      */
 #define OP_Delete                              70
 #define OP_ResetCount                          71
 #define OP_SorterCompare                       72
 #define OP_IsNull                              73   /* same as TK_ISNULL   */
 #define OP_NotNull                             74   /* same as TK_NOTNULL  */
 #define OP_Ne                                  75   /* same as TK_NE       */
 #define OP_Eq                                  76   /* same as TK_EQ       */
 #define OP_Gt                                  77   /* same as TK_GT       */
 #define OP_Le                                  78   /* same as TK_LE       */
 #define OP_Lt                                  79   /* same as TK_LT       */
 #define OP_Ge                                  80   /* same as TK_GE       */
 #define OP_SorterData                          81
 #define OP_BitAnd                              82   /* same as TK_BITAND   */
 #define OP_BitOr                               83   /* same as TK_BITOR    */
 #define OP_ShiftLeft                           84   /* same as TK_LSHIFT   */
 #define OP_ShiftRight                          85   /* same as TK_RSHIFT   */
 #define OP_Add                                 86   /* same as TK_PLUS     */
 #define OP_Subtract                            87   /* same as TK_MINUS    */
 #define OP_Multiply                            88   /* same as TK_STAR     */
 #define OP_Divide                              89   /* same as TK_SLASH    */
 #define OP_Remainder                           90   /* same as TK_REM      */
 #define OP_Concat                              91   /* same as TK_CONCAT   */
 #define OP_RowKey                              92
 #define OP_BitNot                              93   /* same as TK_BITNOT   */
 #define OP_String8                             94   /* same as TK_STRING   */
 #define OP_RowData                             95
 #define OP_Rowid                               96
 #define OP_NullRow                             97
 #define OP_Last                                98
 #define OP_SorterSort                          99
 #define OP_Sort                               100
 #define OP_Rewind                             101
 #define OP_SorterInsert                       102
 #define OP_IdxInsert                          103
 #define OP_IdxDelete                          104
 #define OP_IdxRowid                           105
 #define OP_IdxLT                              106
 #define OP_IdxGE                              107
 #define OP_Destroy                            108
 #define OP_Clear                              109
 #define OP_CreateIndex                        110
 #define OP_CreateTable                        111
 #define OP_ParseSchema                        112
 #define OP_LoadAnalysis                       113
 #define OP_DropTable                          114
 #define OP_DropIndex                          115
 #define OP_DropTrigger                        116
 #define OP_IntegrityCk                        117
 #define OP_RowSetAdd                          118
 #define OP_RowSetRead                         119
 #define OP_RowSetTest                         120
 #define OP_Program                            121
 #define OP_Param                              122
 #define OP_FkCounter                          123
 #define OP_FkIfZero                           124
 #define OP_MemMax                             125
 #define OP_IfPos                              126
 #define OP_IfNeg                              127
 #define OP_IfZero                             128
 #define OP_AggFinal                           129
 #define OP_Real                               130   /* same as TK_FLOAT    */
 #define OP_IncrVacuum                         131
 #define OP_Expire                             132
 #define OP_TableLock                          133
 #define OP_VBegin                             134
 #define OP_VCreate                            135
 #define OP_VDestroy                           136
 #define OP_VOpen                              137
 #define OP_VColumn                            138
 #define OP_VNext                              139
 #define OP_VRename                            140
 #define OP_ToText                             141   /* same as TK_TO_TEXT  */
 #define OP_ToBlob                             142   /* same as TK_TO_BLOB  */
 #define OP_ToNumeric                          143   /* same as TK_TO_NUMERIC*/
 #define OP_ToInt                              144   /* same as TK_TO_INT   */
 #define OP_ToReal                             145   /* same as TK_TO_REAL  */
 #define OP_Pagecount                          146
 #define OP_MaxPgcnt                           147
 #define OP_Trace                              148
 #define OP_Noop                               149
 #define OP_Explain                            150
 #define OP_Function        1 /* synopsis: r[P3]=func(r[P2@P5])             */
 #define OP_Savepoint       2
 #define OP_AutoCommit      3
 #define OP_Transaction     4
 #define OP_SorterNext      5
 #define OP_PrevIfOpen      6
 #define OP_NextIfOpen      7
 #define OP_Prev            8
 #define OP_Next            9
 #define OP_AggStep        10 /* synopsis: accum=r[P3] step(r[P2@P5])       */
 #define OP_Checkpoint     11
 #define OP_JournalMode    12
 #define OP_Vacuum         13
 #define OP_VFilter        14 /* synopsis: iPlan=r[P3] zPlan='P4'           */
 #define OP_VUpdate        15 /* synopsis: data=r[P3@P2]                    */
 #define OP_Goto           16
 #define OP_Gosub          17
 #define OP_Return         18
 #define OP_Not            19 /* same as TK_NOT, synopsis: r[P2]= !r[P1]    */
 #define OP_InitCoroutine  20
 #define OP_EndCoroutine   21
 #define OP_Yield          22
 #define OP_HaltIfNull     23 /* synopsis: if r[P3]=null halt               */
 #define OP_Halt           24
 #define OP_Integer        25 /* synopsis: r[P2]=P1                         */
 #define OP_Int64          26 /* synopsis: r[P2]=P4                         */
 #define OP_String         27 /* synopsis: r[P2]='P4' (len=P1)              */
 #define OP_Null           28 /* synopsis: r[P2..P3]=NULL                   */
 #define OP_SoftNull       29 /* synopsis: r[P1]=NULL                       */
 #define OP_Blob           30 /* synopsis: r[P2]=P4 (len=P1)                */
 #define OP_Variable       31 /* synopsis: r[P2]=parameter(P1,P4)           */
 #define OP_Move           32 /* synopsis: r[P2@P3]=r[P1@P3]                */
 #define OP_Copy           33 /* synopsis: r[P2@P3+1]=r[P1@P3+1]            */
 #define OP_SCopy          34 /* synopsis: r[P2]=r[P1]                      */
 #define OP_ResultRow      35 /* synopsis: output=r[P1@P2]                  */
 #define OP_CollSeq        36
 #define OP_AddImm         37 /* synopsis: r[P1]=r[P1]+P2                   */
 #define OP_MustBeInt      38
 #define OP_RealAffinity   39
 #define OP_Permutation    40
 #define OP_Compare        41
 #define OP_Jump           42
 #define OP_Once           43
 #define OP_If             44
 #define OP_IfNot          45
 #define OP_Column         46 /* synopsis: r[P3]=PX                         */
 #define OP_Affinity       47 /* synopsis: affinity(r[P1@P2])               */
 #define OP_MakeRecord     48 /* synopsis: r[P3]=mkrec(r[P1@P2])            */
 #define OP_Count          49 /* synopsis: r[P2]=count()                    */
 #define OP_ReadCookie     50
 #define OP_SetCookie      51
 #define OP_OpenRead       52 /* synopsis: root=P2 iDb=P3                   */
 #define OP_OpenWrite      53 /* synopsis: root=P2 iDb=P3                   */
 #define OP_OpenAutoindex  54 /* synopsis: nColumn=P2                       */
 #define OP_OpenEphemeral  55 /* synopsis: nColumn=P2                       */
 #define OP_SorterOpen     56
 #define OP_OpenPseudo     57 /* synopsis: P3 columns in r[P2]              */
 #define OP_Close          58
 #define OP_SeekLT         59
 #define OP_SeekLE         60
 #define OP_SeekGE         61
 #define OP_SeekGT         62
 #define OP_Seek           63 /* synopsis: intkey=r[P2]                     */
 #define OP_NoConflict     64 /* synopsis: key=r[P3@P4]                     */
 #define OP_NotFound       65 /* synopsis: key=r[P3@P4]                     */
 #define OP_Found          66 /* synopsis: key=r[P3@P4]                     */
 #define OP_NotExists      67 /* synopsis: intkey=r[P3]                     */
 #define OP_Sequence       68 /* synopsis: r[P2]=rowid                      */
 #define OP_NewRowid       69 /* synopsis: r[P2]=rowid                      */
 #define OP_Insert         70 /* synopsis: intkey=r[P3] data=r[P2]          */
 #define OP_Or             71 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */
 #define OP_And            72 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */
 #define OP_InsertInt      73 /* synopsis: intkey=P3 data=r[P2]             */
 #define OP_Delete         74
 #define OP_ResetCount     75
 #define OP_IsNull         76 /* same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */
 #define OP_NotNull        77 /* same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */
 #define OP_Ne             78 /* same as TK_NE, synopsis: if r[P1]!=r[P3] goto P2 */
 #define OP_Eq             79 /* same as TK_EQ, synopsis: if r[P1]==r[P3] goto P2 */
 #define OP_Gt             80 /* same as TK_GT, synopsis: if r[P1]>r[P3] goto P2 */
 #define OP_Le             81 /* same as TK_LE, synopsis: if r[P1]<=r[P3] goto P2 */
 #define OP_Lt             82 /* same as TK_LT, synopsis: if r[P1]<r[P3] goto P2 */
 #define OP_Ge             83 /* same as TK_GE, synopsis: if r[P1]>=r[P3] goto P2 */
 #define OP_SorterCompare  84 /* synopsis: if key(P1)!=rtrim(r[P3],P4) goto P2 */
 #define OP_BitAnd         85 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */
 #define OP_BitOr          86 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */
 #define OP_ShiftLeft      87 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */
 #define OP_ShiftRight     88 /* same as TK_RSHIFT, synopsis: r[P3]=r[P2]>>r[P1] */
 #define OP_Add            89 /* same as TK_PLUS, synopsis: r[P3]=r[P1]+r[P2] */
 #define OP_Subtract       90 /* same as TK_MINUS, synopsis: r[P3]=r[P2]-r[P1] */
 #define OP_Multiply       91 /* same as TK_STAR, synopsis: r[P3]=r[P1]*r[P2] */
 #define OP_Divide         92 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
 #define OP_Remainder      93 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
 #define OP_Concat         94 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
 #define OP_SorterData     95 /* synopsis: r[P2]=data                       */
 #define OP_BitNot         96 /* same as TK_BITNOT, synopsis: r[P1]= ~r[P1] */
 #define OP_String8        97 /* same as TK_STRING, synopsis: r[P2]='P4'    */
 #define OP_RowKey         98 /* synopsis: r[P2]=key                        */
 #define OP_RowData        99 /* synopsis: r[P2]=data                       */
 #define OP_Rowid         100 /* synopsis: r[P2]=rowid                      */
 #define OP_NullRow       101
 #define OP_Last          102
 #define OP_SorterSort    103
 #define OP_Sort          104
 #define OP_Rewind        105
 #define OP_SorterInsert  106
 #define OP_IdxInsert     107 /* synopsis: key=r[P2]                        */
 #define OP_IdxDelete     108 /* synopsis: key=r[P2@P3]                     */
 #define OP_IdxRowid      109 /* synopsis: r[P2]=rowid                      */
 #define OP_IdxLE         110 /* synopsis: key=r[P3@P4]                     */
 #define OP_IdxGT         111 /* synopsis: key=r[P3@P4]                     */
 #define OP_IdxLT         112 /* synopsis: key=r[P3@P4]                     */
 #define OP_IdxGE         113 /* synopsis: key=r[P3@P4]                     */
 #define OP_Destroy       114
 #define OP_Clear         115
 #define OP_CreateIndex   116 /* synopsis: r[P2]=root iDb=P1                */
 #define OP_CreateTable   117 /* synopsis: r[P2]=root iDb=P1                */
 #define OP_ParseSchema   118
 #define OP_LoadAnalysis  119
 #define OP_DropTable     120
 #define OP_DropIndex     121
 #define OP_DropTrigger   122
 #define OP_IntegrityCk   123
 #define OP_RowSetAdd     124 /* synopsis: rowset(P1)=r[P2]                 */
 #define OP_RowSetRead    125 /* synopsis: r[P3]=rowset(P1)                 */
 #define OP_RowSetTest    126 /* synopsis: if r[P3] in rowset(P1) goto P2   */
 #define OP_Program       127
 #define OP_Param         128
 #define OP_FkCounter     129 /* synopsis: fkctr[P1]+=P2                    */
 #define OP_FkIfZero      130 /* synopsis: if fkctr[P1]==0 goto P2          */
 #define OP_MemMax        131 /* synopsis: r[P1]=max(r[P1],r[P2])           */
 #define OP_IfPos         132 /* synopsis: if r[P1]>0 goto P2               */
 #define OP_Real          133 /* same as TK_FLOAT, synopsis: r[P2]=P4       */
 #define OP_IfNeg         134 /* synopsis: if r[P1]<0 goto P2               */
 #define OP_IfZero        135 /* synopsis: r[P1]+=P3, if r[P1]==0 goto P2   */
 #define OP_AggFinal      136 /* synopsis: accum=r[P1] N=P2                 */
 #define OP_IncrVacuum    137
 #define OP_Expire        138
 #define OP_TableLock     139 /* synopsis: iDb=P1 root=P2 write=P3          */
 #define OP_VBegin        140
 #define OP_VCreate       141
 #define OP_VDestroy      142
 #define OP_ToText        143 /* same as TK_TO_TEXT                         */
 #define OP_ToBlob        144 /* same as TK_TO_BLOB                         */
 #define OP_ToNumeric     145 /* same as TK_TO_NUMERIC                      */
 #define OP_ToInt         146 /* same as TK_TO_INT                          */
 #define OP_ToReal        147 /* same as TK_TO_REAL                         */
 #define OP_VOpen         148
 #define OP_VColumn       149 /* synopsis: r[P3]=vcolumn(P2)                */
 #define OP_VNext         150
 #define OP_VRename       151
 #define OP_Pagecount     152
 #define OP_MaxPgcnt      153
 #define OP_Init          154 /* synopsis: Start at P2                      */
 #define OP_Noop          155
 #define OP_Explain       156
 /* Properties such as "out2" or "jump" that are specified in

@@ -9149,24 +9294,25 @@ typedef struct VdbeOpList VdbeOpList;

 #define OPFLG_OUT3            0x0040  /* out3:  P3 is an output */
 #define OPFLG_INITIALIZER {\
 /*   0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,\
 /*   8 */ 0x00, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x01,\
 /*  16 */ 0x04, 0x04, 0x10, 0x24, 0x00, 0x02, 0x02, 0x02,\
 /*  24 */ 0x02, 0x02, 0x02, 0x00, 0x00, 0x24, 0x00, 0x00,\
 /*  32 */ 0x04, 0x05, 0x04, 0x00, 0x00, 0x01, 0x01, 0x05,\
 /*  40 */ 0x05, 0x00, 0x00, 0x00, 0x02, 0x02, 0x10, 0x00,\
 /*  48 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,\
 /*  56 */ 0x11, 0x11, 0x11, 0x08, 0x11, 0x11, 0x11, 0x11,\
 /*  64 */ 0x02, 0x02, 0x00, 0x00, 0x4c, 0x4c, 0x00, 0x00,\
 /*  72 */ 0x00, 0x05, 0x05, 0x15, 0x15, 0x15, 0x15, 0x15,\
 /*  80 */ 0x15, 0x00, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,\
 /*  88 */ 0x4c, 0x4c, 0x4c, 0x4c, 0x00, 0x24, 0x02, 0x00,\
 /*  96 */ 0x02, 0x00, 0x01, 0x01, 0x01, 0x01, 0x08, 0x08,\
 /* 104 */ 0x00, 0x02, 0x01, 0x01, 0x02, 0x00, 0x02, 0x02,\
 /* 112 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x45,\
 /* 120 */ 0x15, 0x01, 0x02, 0x00, 0x01, 0x08, 0x05, 0x05,\
 /* 128 */ 0x05, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00,\
 /* 136 */ 0x00, 0x00, 0x00, 0x01, 0x00, 0x04, 0x04, 0x04,\
 /* 144 */ 0x04, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00,}
 /*   8 */ 0x01, 0x01, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00,\
 /*  16 */ 0x01, 0x01, 0x04, 0x24, 0x01, 0x04, 0x05, 0x10,\
 /*  24 */ 0x00, 0x02, 0x02, 0x02, 0x02, 0x00, 0x02, 0x02,\
 /*  32 */ 0x00, 0x00, 0x20, 0x00, 0x00, 0x04, 0x05, 0x04,\
 /*  40 */ 0x00, 0x00, 0x01, 0x01, 0x05, 0x05, 0x00, 0x00,\
 /*  48 */ 0x00, 0x02, 0x02, 0x10, 0x00, 0x00, 0x00, 0x00,\
 /*  56 */ 0x00, 0x00, 0x00, 0x11, 0x11, 0x11, 0x11, 0x08,\
 /*  64 */ 0x11, 0x11, 0x11, 0x11, 0x02, 0x02, 0x00, 0x4c,\
 /*  72 */ 0x4c, 0x00, 0x00, 0x00, 0x05, 0x05, 0x15, 0x15,\
 /*  80 */ 0x15, 0x15, 0x15, 0x15, 0x00, 0x4c, 0x4c, 0x4c,\
 /*  88 */ 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x00,\
 /*  96 */ 0x24, 0x02, 0x00, 0x00, 0x02, 0x00, 0x01, 0x01,\
 /* 104 */ 0x01, 0x01, 0x08, 0x08, 0x00, 0x02, 0x01, 0x01,\
 /* 112 */ 0x01, 0x01, 0x02, 0x00, 0x02, 0x02, 0x00, 0x00,\
 /* 120 */ 0x00, 0x00, 0x00, 0x00, 0x0c, 0x45, 0x15, 0x01,\
 /* 128 */ 0x02, 0x00, 0x01, 0x08, 0x05, 0x02, 0x05, 0x05,\
 /* 136 */ 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,\
 /* 144 */ 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x01, 0x00,\
 /* 152 */ 0x02, 0x02, 0x01, 0x00, 0x00,}
 /************** End of opcodes.h *********************************************/
 /************** Continuing where we left off in vdbe.h ***********************/

@@ -9175,14 +9321,14 @@ typedef struct VdbeOpList VdbeOpList;

 ** Prototypes for the VDBE interface.  See comments on the implementation
 ** for a description of what each of these routines does.
 */
 SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3*);
 SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse*);
 SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int);
 SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int);
 SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int);
 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int);
 SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int);
 SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int);
 SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp);
 SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp, int iLineno);
 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*);
 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1);
 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);

@@ -9190,7 +9336,9 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3);

 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr);
 SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr);
 SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe*, u8 op);
 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
 SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse*, Index*);
 SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int);
 SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int);
 SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe*);

@@ -9203,7 +9351,6 @@ SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int);

 SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*);
 #ifdef SQLITE_DEBUG
 SQLITE_PRIVATE   int sqlite3VdbeAssertMayAbort(Vdbe *, int);
 SQLITE_PRIVATE   void sqlite3VdbeTrace(Vdbe*,FILE*);
 #endif
 SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*);
 SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe*);

@@ -9222,22 +9369,74 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*);

 #endif
 SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,UnpackedRecord*);
 SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*);
 SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,const UnpackedRecord*,int);
 SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(KeyInfo *, char *, int, char **);
 typedef int (*RecordCompare)(int,const void*,const UnpackedRecord*,int);
 SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord*);
 #ifndef SQLITE_OMIT_TRIGGER
 SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *);
 #endif
 #ifndef NDEBUG
 /* Use SQLITE_ENABLE_COMMENTS to enable generation of extra comments on
 ** each VDBE opcode.
 **
 ** Use the SQLITE_ENABLE_MODULE_COMMENTS macro to see some extra no-op
 ** comments in VDBE programs that show key decision points in the code
 ** generator.
 */
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
 SQLITE_PRIVATE   void sqlite3VdbeComment(Vdbe*, const char*, ...);
 # define VdbeComment(X)  sqlite3VdbeComment X
 SQLITE_PRIVATE   void sqlite3VdbeNoopComment(Vdbe*, const char*, ...);
 # define VdbeNoopComment(X)  sqlite3VdbeNoopComment X
 # ifdef SQLITE_ENABLE_MODULE_COMMENTS
 #   define VdbeModuleComment(X)  sqlite3VdbeNoopComment X
 # else
 #   define VdbeModuleComment(X)
 # endif
 #else
 # define VdbeComment(X)
 # define VdbeNoopComment(X)
 # define VdbeModuleComment(X)
 #endif
 /*
 ** The VdbeCoverage macros are used to set a coverage testing point
 ** for VDBE branch instructions.  The coverage testing points are line
 ** numbers in the sqlite3.c source file.  VDBE branch coverage testing
 ** only works with an amalagmation build.  That's ok since a VDBE branch
 ** coverage build designed for testing the test suite only.  No application
 ** should ever ship with VDBE branch coverage measuring turned on.
 **
 **    VdbeCoverage(v)                  // Mark the previously coded instruction
 **                                     // as a branch
 **
 **    VdbeCoverageIf(v, conditional)   // Mark previous if conditional true
 **
 **    VdbeCoverageAlwaysTaken(v)       // Previous branch is always taken
 **
 **    VdbeCoverageNeverTaken(v)        // Previous branch is never taken
 **
 ** Every VDBE branch operation must be tagged with one of the macros above.
 ** If not, then when "make test" is run with -DSQLITE_VDBE_COVERAGE and
 ** -DSQLITE_DEBUG then an ALWAYS() will fail in the vdbeTakeBranch()
 ** routine in vdbe.c, alerting the developer to the missed tag.
 */
 #ifdef SQLITE_VDBE_COVERAGE
 SQLITE_PRIVATE   void sqlite3VdbeSetLineNumber(Vdbe*,int);
 # define VdbeCoverage(v) sqlite3VdbeSetLineNumber(v,__LINE__)
 # define VdbeCoverageIf(v,x) if(x)sqlite3VdbeSetLineNumber(v,__LINE__)
 # define VdbeCoverageAlwaysTaken(v) sqlite3VdbeSetLineNumber(v,2);
 # define VdbeCoverageNeverTaken(v) sqlite3VdbeSetLineNumber(v,1);
 # define VDBE_OFFSET_LINENO(x) (__LINE__+x)
 #else
 # define VdbeCoverage(v)
 # define VdbeCoverageIf(v,x)
 # define VdbeCoverageAlwaysTaken(v)
 # define VdbeCoverageNeverTaken(v)
 # define VDBE_OFFSET_LINENO(x) 0
 #endif
 #endif

@@ -9384,6 +9583,7 @@ SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage

 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
 SQLITE_PRIVATE void sqlite3PagerRef(DbPage*);
 SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*);
 SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage*);
 /* Operations on page references. */
 SQLITE_PRIVATE int sqlite3PagerWrite(DbPage*);

@@ -9398,7 +9598,7 @@ SQLITE_PRIVATE void sqlite3PagerPagecount(Pager*, int*);

 SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int);
 SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, int);
 SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager*);
 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager);
 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zMaster);
 SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*);
 SQLITE_PRIVATE int sqlite3PagerRollback(Pager*);
 SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);

@@ -10258,6 +10458,7 @@ struct sqlite3 {

 #define SQLITE_EnableTrigger  0x00800000  /* True to enable triggers */
 #define SQLITE_DeferFKs       0x01000000  /* Defer all FK constraints */
 #define SQLITE_QueryOnly      0x02000000  /* Disable database changes */
 #define SQLITE_VdbeEQP        0x04000000  /* Debug EXPLAIN QUERY PLAN */
 /*

@@ -10269,7 +10470,7 @@ struct sqlite3 {

 #define SQLITE_ColumnCache    0x0002   /* Column cache */
 #define SQLITE_GroupByOrder   0x0004   /* GROUPBY cover of ORDERBY */
 #define SQLITE_FactorOutConst 0x0008   /* Constant factoring */
 #define SQLITE_IdxRealAsInt   0x0010   /* Store REAL as INT in indices */
 /*                not used    0x0010   // Was: SQLITE_IdxRealAsInt */
 #define SQLITE_DistinctOpt    0x0020   /* DISTINCT using indexes */
 #define SQLITE_CoverIdxScan   0x0040   /* Covering index scans */
 #define SQLITE_OrderByIdxJoin 0x0080   /* ORDER BY of joins via index */

@@ -10292,6 +10493,12 @@ struct sqlite3 {

 #endif
 /*
 ** Return true if it OK to factor constant expressions into the initialization
 ** code. The argument is a Parse object for the code generator.
 */
 #define ConstFactorOk(P) ((P)->okConstFactor)
 /*
 ** Possible values for the sqlite.magic field.
 ** The numbers are obtained at random and have no special meaning, other
 ** than being distinct from one another.

@@ -10357,6 +10564,7 @@ struct FuncDestructor {

 #define SQLITE_FUNC_COUNT    0x100 /* Built-in count(*) aggregate */
 #define SQLITE_FUNC_COALESCE 0x200 /* Built-in coalesce() or ifnull() */
 #define SQLITE_FUNC_UNLIKELY 0x400 /* Built-in unlikely() function */
 #define SQLITE_FUNC_CONSTANT 0x800 /* Constant inputs give a constant output */
 /*
 ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are

@@ -10369,6 +10577,9 @@ struct FuncDestructor {

 **     as the user-data (sqlite3_user_data()) for the function. If
 **     argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
 **
 **   VFUNCTION(zName, nArg, iArg, bNC, xFunc)
 **     Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag.
 **
 **   AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
 **     Used to create an aggregate function definition implemented by
 **     the C functions xStep and xFinal. The first four parameters

@@ -10384,16 +10595,20 @@ struct FuncDestructor {

 **     parameter.
 */
 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
    SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
    SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
   {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags, \
   {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
    SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
   {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
   {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
    pArg, 0, xFunc, 0, 0, #zName, 0, 0}
 #define LIKEFUNC(zName, nArg, arg, flags) \
   {nArg, SQLITE_UTF8|flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}
   {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
    (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}
 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
   {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \
    SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}

@@ -10507,10 +10722,16 @@ struct CollSeq {

 /*
 ** Additional bit values that can be ORed with an affinity without
 ** changing the affinity.
 **
 ** The SQLITE_NOTNULL flag is a combination of NULLEQ and JUMPIFNULL.
 ** It causes an assert() to fire if either operand to a comparison
 ** operator is NULL.  It is added to certain comparison operators to
 ** prove that the operands are always NOT NULL.
 */
 #define SQLITE_JUMPIFNULL   0x08  /* jumps if either operand is NULL */
 #define SQLITE_STOREP2      0x10  /* Store result in reg[P2] rather than jump */
 #define SQLITE_NULLEQ       0x80  /* NULL=NULL */
 #define SQLITE_NOTNULL      0x88  /* Assert that operands are never NULL */
 /*
 ** An object of this type is created for each virtual table present in

@@ -10626,13 +10847,14 @@ struct Table {

 };
 /*
 ** Allowed values for Tabe.tabFlags.
 ** Allowed values for Table.tabFlags.
 */
 #define TF_Readonly        0x01    /* Read-only system table */
 #define TF_Ephemeral       0x02    /* An ephemeral table */
 #define TF_HasPrimaryKey   0x04    /* Table has a primary key */
 #define TF_Autoincrement   0x08    /* Integer primary key is autoincrement */
 #define TF_Virtual         0x10    /* Is a virtual table */
 #define TF_WithoutRowid    0x20    /* No rowid used. PRIMARY KEY is the key */
 /*

@@ -10648,6 +10870,9 @@ struct Table {

 #  define IsHiddenColumn(X) 0
 #endif
 /* Does the table have a rowid */
 #define HasRowid(X)     (((X)->tabFlags & TF_WithoutRowid)==0)
 /*
 ** Each foreign key constraint is an instance of the following structure.
 **

@@ -10662,26 +10887,35 @@ struct Table {

 **     );
 **
 ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
 ** Equivalent names:
 **
 **     from-table == child-table
 **       to-table == parent-table
 **
 ** Each REFERENCES clause generates an instance of the following structure
 ** which is attached to the from-table.  The to-table need not exist when
 ** the from-table is created.  The existence of the to-table is not checked.
 **
 ** The list of all parents for child Table X is held at X.pFKey.
 **
 ** A list of all children for a table named Z (which might not even exist)
 ** is held in Schema.fkeyHash with a hash key of Z.
 */
 struct FKey {
   Table *pFrom;     /* Table containing the REFERENCES clause (aka: Child) */
   FKey *pNextFrom;  /* Next foreign key in pFrom */
   FKey *pNextFrom;  /* Next FKey with the same in pFrom. Next parent of pFrom */
   char *zTo;        /* Name of table that the key points to (aka: Parent) */
   FKey *pNextTo;    /* Next foreign key on table named zTo */
   FKey *pPrevTo;    /* Previous foreign key on table named zTo */
   FKey *pNextTo;    /* Next with the same zTo. Next child of zTo. */
   FKey *pPrevTo;    /* Previous with the same zTo */
   int nCol;         /* Number of columns in this key */
   /* EV: R-30323-21917 */
   u8 isDeferred;    /* True if constraint checking is deferred till COMMIT */
   u8 aAction[2];          /* ON DELETE and ON UPDATE actions, respectively */
   Trigger *apTrigger[2];  /* Triggers for aAction[] actions */
   struct sColMap {  /* Mapping of columns in pFrom to columns in zTo */
     int iFrom;         /* Index of column in pFrom */
     char *zCol;        /* Name of column in zTo.  If 0 use PRIMARY KEY */
   } aCol[1];        /* One entry for each of nCol column s */
   u8 isDeferred;       /* True if constraint checking is deferred till COMMIT */
   u8 aAction[2];        /* ON DELETE and ON UPDATE actions, respectively */
   Trigger *apTrigger[2];/* Triggers for aAction[] actions */
   struct sColMap {      /* Mapping of columns in pFrom to columns in zTo */
     int iFrom;            /* Index of column in pFrom */
     char *zCol;           /* Name of column in zTo.  If NULL use PRIMARY KEY */
   } aCol[1];            /* One entry for each of nCol columns */
 };
 /*

@@ -10734,9 +10968,11 @@ struct FKey {

 ** for the rowid at the end.
 */
 struct KeyInfo {
   sqlite3 *db;        /* The database connection */
   u32 nRef;           /* Number of references to this KeyInfo object */
   u8 enc;             /* Text encoding - one of the SQLITE_UTF* values */
   u16 nField;         /* Maximum index for aColl[] and aSortOrder[] */
   u16 nField;         /* Number of key columns in the index */
   u16 nXField;        /* Number of columns beyond the key columns */
   sqlite3 *db;        /* The database connection */
   u8 *aSortOrder;     /* Sort order for each column. */
   CollSeq *aColl[1];  /* Collating sequence for each term of the key */
 };

@@ -10754,21 +10990,19 @@ struct KeyInfo {

 **
 ** This structure holds a record that has already been disassembled
 ** into its constituent fields.
 **
 ** The r1 and r2 member variables are only used by the optimized comparison
 ** functions vdbeRecordCompareInt() and vdbeRecordCompareString().
 */
 struct UnpackedRecord {
   KeyInfo *pKeyInfo;  /* Collation and sort-order information */
   u16 nField;         /* Number of entries in apMem[] */
   u8 flags;           /* Boolean settings.  UNPACKED_... below */
   i64 rowid;          /* Used by UNPACKED_PREFIX_SEARCH */
   i8 default_rc;      /* Comparison result if keys are equal */
   Mem *aMem;          /* Values */
   int r1;             /* Value to return if (lhs > rhs) */
   int r2;             /* Value to return if (rhs < lhs) */
 };
 /*
 ** Allowed values of UnpackedRecord.flags
 */
 #define UNPACKED_INCRKEY       0x01  /* Make this key an epsilon larger */
 #define UNPACKED_PREFIX_MATCH  0x02  /* A prefix match is considered OK */
 #define UNPACKED_PREFIX_SEARCH 0x04  /* Ignore final (rowid) field */
 /*
 ** Each SQL index is represented in memory by an

@@ -10798,7 +11032,7 @@ struct UnpackedRecord {

 */
 struct Index {
   char *zName;             /* Name of this index */
   int *aiColumn;           /* Which columns are used by this index.  1st is 0 */
   i16 *aiColumn;           /* Which columns are used by this index.  1st is 0 */
   tRowcnt *aiRowEst;       /* From ANALYZE: Est. rows selected by each column */
   Table *pTable;           /* The SQL table being indexed */
   char *zColAff;           /* String defining the affinity of each column */

@@ -10807,13 +11041,17 @@ struct Index {

   u8 *aSortOrder;          /* for each column: True==DESC, False==ASC */
   char **azColl;           /* Array of collation sequence names for index */
   Expr *pPartIdxWhere;     /* WHERE clause for partial indices */
   KeyInfo *pKeyInfo;       /* A KeyInfo object suitable for this index */
   int tnum;                /* DB Page containing root of this index */
   LogEst szIdxRow;         /* Estimated average row size in bytes */
   u16 nColumn;             /* Number of columns in table used by this index */
   u16 nKeyCol;             /* Number of columns forming the key */
   u16 nColumn;             /* Number of columns stored in the index */
   u8 onError;              /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
   unsigned autoIndex:2;    /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */
   unsigned bUnordered:1;   /* Use this index for == or IN queries only */
   unsigned uniqNotNull:1;  /* True if UNIQUE and NOT NULL for all columns */
   unsigned isResized:1;    /* True if resizeIndexObject() has been called */
   unsigned isCovering:1;   /* True if this is a covering index */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   int nSample;             /* Number of elements in aSample[] */
   int nSampleCol;          /* Size of IndexSample.anEq[] and so on */

@@ -10869,6 +11107,7 @@ struct AggInfo {

   int sortingIdx;         /* Cursor number of the sorting index */
   int sortingIdxPTab;     /* Cursor number of pseudo-table */
   int nSortingColumn;     /* Number of columns in the sorting index */
   int mnReg, mxReg;       /* Range of registers allocated for aCol and aFunc */
   ExprList *pGroupBy;     /* The group by clause */
   struct AggInfo_col {    /* For each column used in source tables */
     Table *pTab;             /* Source table */

@@ -11026,7 +11265,7 @@ struct Expr {

 #define EP_DblQuoted 0x000040 /* token.z was originally in "..." */
 #define EP_InfixFunc 0x000080 /* True for an infix function: LIKE, GLOB, etc */
 #define EP_Collate   0x000100 /* Tree contains a TK_COLLATE opeartor */
 #define EP_FixedDest 0x000200 /* Result needed in a specific register */
       /* unused      0x000200 */
 #define EP_IntValue  0x000400 /* Integer value contained in u.iValue */
 #define EP_xIsSelect 0x000800 /* x.pSelect is valid (otherwise x.pList is) */
 #define EP_Skip      0x001000 /* COLLATE, AS, or UNLIKELY */

@@ -11036,6 +11275,7 @@ struct Expr {

 #define EP_MemToken  0x010000 /* Need to sqlite3DbFree() Expr.zToken */
 #define EP_NoReduce  0x020000 /* Cannot EXPRDUP_REDUCE this Expr */
 #define EP_Unlikely  0x040000 /* unlikely() or likelihood() function */
 #define EP_Constant  0x080000 /* Node is a constant */
 /*
 ** These macros can be used to test, set, or clear bits in the

@@ -11097,8 +11337,14 @@ struct ExprList {

     u8 sortOrder;           /* 1 for DESC or 0 for ASC */
     unsigned done :1;       /* A flag to indicate when processing is finished */
     unsigned bSpanIsTab :1; /* zSpan holds DB.TABLE.COLUMN */
     u16 iOrderByCol;        /* For ORDER BY, column number in result set */
     u16 iAlias;             /* Index into Parse.aAlias[] for zName */
     unsigned reusable :1;   /* Constant expression is reusable */
     union {
       struct {
         u16 iOrderByCol;      /* For ORDER BY, column number in result set */
         u16 iAlias;           /* Index into Parse.aAlias[] for zName */
       } x;
       int iConstExprReg;      /* Register in which Expr value is cached */
     } u;
   } *a;                  /* Alloc a power of two greater or equal to nExpr */
 };

@@ -11154,6 +11400,7 @@ typedef u64 Bitmask;

 ** A bit in a Bitmask
 */
 #define MASKBIT(n)   (((Bitmask)1)<<(n))
 #define MASKBIT32(n) (((unsigned int)1)<<(n))
 /*
 ** The following structure describes the FROM clause of a SELECT statement.

@@ -11175,8 +11422,8 @@ typedef u64 Bitmask;

 ** contains more than 63 columns and the 64-th or later column is used.
 */
 struct SrcList {
   u8 nSrc;        /* Number of tables or subqueries in the FROM clause */
   u8 nAlloc;      /* Number of entries allocated in a[] below */
   int nSrc;        /* Number of tables or subqueries in the FROM clause */
   u32 nAlloc;      /* Number of entries allocated in a[] below */
   struct SrcList_item {
     Schema *pSchema;  /* Schema to which this item is fixed */
     char *zDatabase;  /* Name of database holding this table */

@@ -11186,10 +11433,12 @@ struct SrcList {

     Select *pSelect;  /* A SELECT statement used in place of a table name */
     int addrFillSub;  /* Address of subroutine to manifest a subquery */
     int regReturn;    /* Register holding return address of addrFillSub */
     int regResult;    /* Registers holding results of a co-routine */
     u8 jointype;      /* Type of join between this able and the previous */
     unsigned notIndexed :1;    /* True if there is a NOT INDEXED clause */
     unsigned isCorrelated :1;  /* True if sub-query is correlated */
     unsigned viaCoroutine :1;  /* Implemented as a co-routine */
     unsigned isRecursive :1;   /* True for recursive reference in WITH */
 #ifndef SQLITE_OMIT_EXPLAIN
     u8 iSelectId;     /* If pSelect!=0, the id of the sub-select in EQP */
 #endif

@@ -11313,9 +11562,9 @@ struct Select {

   ExprList *pOrderBy;    /* The ORDER BY clause */
   Select *pPrior;        /* Prior select in a compound select statement */
   Select *pNext;         /* Next select to the left in a compound */
   Select *pRightmost;    /* Right-most select in a compound select statement */
   Expr *pLimit;          /* LIMIT expression. NULL means not used. */
   Expr *pOffset;         /* OFFSET expression. NULL means not used. */
   With *pWith;           /* WITH clause attached to this select. Or NULL. */
 };
 /*

@@ -11330,14 +11579,74 @@ struct Select {

 #define SF_HasTypeInfo     0x0020  /* FROM subqueries have Table metadata */
 #define SF_UseSorter       0x0040  /* Sort using a sorter */
 #define SF_Values          0x0080  /* Synthesized from VALUES clause */
 #define SF_Materialize     0x0100  /* Force materialization of views */
 #define SF_Materialize     0x0100  /* NOT USED */
 #define SF_NestedFrom      0x0200  /* Part of a parenthesized FROM clause */
 #define SF_MaybeConvert    0x0400  /* Need convertCompoundSelectToSubquery() */
 #define SF_Recursive       0x0800  /* The recursive part of a recursive CTE */
 #define SF_Compound        0x1000  /* Part of a compound query */
 /*
 ** The results of a select can be distributed in several ways.  The
 ** "SRT" prefix means "SELECT Result Type".
 ** The results of a SELECT can be distributed in several ways, as defined
 ** by one of the following macros.  The "SRT" prefix means "SELECT Result
 ** Type".
 **
 **     SRT_Union       Store results as a key in a temporary index
 **                     identified by pDest->iSDParm.
 **
 **     SRT_Except      Remove results from the temporary index pDest->iSDParm.
 **
 **     SRT_Exists      Store a 1 in memory cell pDest->iSDParm if the result
 **                     set is not empty.
 **
 **     SRT_Discard     Throw the results away.  This is used by SELECT
 **                     statements within triggers whose only purpose is
 **                     the side-effects of functions.
 **
 ** All of the above are free to ignore their ORDER BY clause. Those that
 ** follow must honor the ORDER BY clause.
 **
 **     SRT_Output      Generate a row of output (using the OP_ResultRow
 **                     opcode) for each row in the result set.
 **
 **     SRT_Mem         Only valid if the result is a single column.
 **                     Store the first column of the first result row
 **                     in register pDest->iSDParm then abandon the rest
 **                     of the query.  This destination implies "LIMIT 1".
 **
 **     SRT_Set         The result must be a single column.  Store each
 **                     row of result as the key in table pDest->iSDParm.
 **                     Apply the affinity pDest->affSdst before storing
 **                     results.  Used to implement "IN (SELECT ...)".
 **
 **     SRT_EphemTab    Create an temporary table pDest->iSDParm and store
 **                     the result there. The cursor is left open after
 **                     returning.  This is like SRT_Table except that
 **                     this destination uses OP_OpenEphemeral to create
 **                     the table first.
 **
 **     SRT_Coroutine   Generate a co-routine that returns a new row of
 **                     results each time it is invoked.  The entry point
 **                     of the co-routine is stored in register pDest->iSDParm
 **                     and the result row is stored in pDest->nDest registers
 **                     starting with pDest->iSdst.
 **
 **     SRT_Table       Store results in temporary table pDest->iSDParm.
 **                     This is like SRT_EphemTab except that the table
 **                     is assumed to already be open.
 **
 **     SRT_DistTable   Store results in a temporary table pDest->iSDParm.
 **                     But also use temporary table pDest->iSDParm+1 as
 **                     a record of all prior results and ignore any duplicate
 **                     rows.  Name means:  "Distinct Table".
 **
 **     SRT_Queue       Store results in priority queue pDest->iSDParm (really
 **                     an index).  Append a sequence number so that all entries
 **                     are distinct.
 **
 **     SRT_DistQueue   Store results in priority queue pDest->iSDParm only if
 **                     the same record has never been stored before.  The
 **                     index at pDest->iSDParm+1 hold all prior stores.
 */
 #define SRT_Union        1  /* Store result as keys in an index */
 #define SRT_Except       2  /* Remove result from a UNION index */

@@ -11350,20 +11659,24 @@ struct Select {

 #define SRT_Output       5  /* Output each row of result */
 #define SRT_Mem          6  /* Store result in a memory cell */
 #define SRT_Set          7  /* Store results as keys in an index */
 #define SRT_Table        8  /* Store result as data with an automatic rowid */
 #define SRT_EphemTab     9  /* Create transient tab and store like SRT_Table */
 #define SRT_Coroutine   10  /* Generate a single row of result */
 #define SRT_EphemTab     8  /* Create transient tab and store like SRT_Table */
 #define SRT_Coroutine    9  /* Generate a single row of result */
 #define SRT_Table       10  /* Store result as data with an automatic rowid */
 #define SRT_DistTable   11  /* Like SRT_Table, but unique results only */
 #define SRT_Queue       12  /* Store result in an queue */
 #define SRT_DistQueue   13  /* Like SRT_Queue, but unique results only */
 /*
 ** An instance of this object describes where to put of the results of
 ** a SELECT statement.
 */
 struct SelectDest {
   u8 eDest;         /* How to dispose of the results.  On of SRT_* above. */
   char affSdst;     /* Affinity used when eDest==SRT_Set */
   int iSDParm;      /* A parameter used by the eDest disposal method */
   int iSdst;        /* Base register where results are written */
   int nSdst;        /* Number of registers allocated */
   u8 eDest;            /* How to dispose of the results.  On of SRT_* above. */
   char affSdst;        /* Affinity used when eDest==SRT_Set */
   int iSDParm;         /* A parameter used by the eDest disposal method */
   int iSdst;           /* Base register where results are written */
   int nSdst;           /* Number of registers allocated */
   ExprList *pOrderBy;  /* Key columns for SRT_Queue and SRT_DistQueue */
 };
 /*

@@ -11449,12 +11762,12 @@ struct Parse {

   u8 checkSchema;      /* Causes schema cookie check after an error */
   u8 nested;           /* Number of nested calls to the parser/code generator */
   u8 nTempReg;         /* Number of temporary registers in aTempReg[] */
   u8 nTempInUse;       /* Number of aTempReg[] currently checked out */
   u8 nColCache;        /* Number of entries in aColCache[] */
   u8 iColCache;        /* Next entry in aColCache[] to replace */
   u8 isMultiWrite;     /* True if statement may modify/insert multiple rows */
   u8 mayAbort;         /* True if statement may throw an ABORT exception */
   u8 hasCompound;      /* Need to invoke convertCompoundSelectToSubquery() */
   u8 okConstFactor;    /* OK to factor out constants */
   int aTempReg[8];     /* Holding area for temporary registers */
   int nRangeReg;       /* Size of the temporary register block */
   int iRangeReg;       /* First register in temporary register block */

@@ -11463,26 +11776,30 @@ struct Parse {

   int nMem;            /* Number of memory cells used so far */
   int nSet;            /* Number of sets used so far */
   int nOnce;           /* Number of OP_Once instructions so far */
   int nOpAlloc;        /* Number of slots allocated for Vdbe.aOp[] */
   int iFixedOp;        /* Never back out opcodes iFixedOp-1 or earlier */
   int ckBase;          /* Base register of data during check constraints */
   int iPartIdxTab;     /* Table corresponding to a partial index */
   int iCacheLevel;     /* ColCache valid when aColCache[].iLevel<=iCacheLevel */
   int iCacheCnt;       /* Counter used to generate aColCache[].lru values */
   int nLabel;          /* Number of labels used */
   int *aLabel;         /* Space to hold the labels */
   struct yColCache {
     int iTable;           /* Table cursor number */
     int iColumn;          /* Table column number */
     i16 iColumn;          /* Table column number */
     u8 tempReg;           /* iReg is a temp register that needs to be freed */
     int iLevel;           /* Nesting level */
     int iReg;             /* Reg with value of this column. 0 means none. */
     int lru;              /* Least recently used entry has the smallest value */
   } aColCache[SQLITE_N_COLCACHE];  /* One for each column cache entry */
   ExprList *pConstExpr;/* Constant expressions */
   Token constraintName;/* Name of the constraint currently being parsed */
   yDbMask writeMask;   /* Start a write transaction on these databases */
   yDbMask cookieMask;  /* Bitmask of schema verified databases */
   int cookieGoto;      /* Address of OP_Goto to cookie verifier subroutine */
   int cookieValue[SQLITE_MAX_ATTACHED+2];  /* Values of cookies to verify */
   int regRowid;        /* Register holding rowid of CREATE TABLE entry */
   int regRoot;         /* Register holding root page number for new objects */
   int nMaxArg;         /* Max args passed to user function by sub-program */
   Token constraintName;/* Name of the constraint currently being parsed */
 #ifndef SQLITE_OMIT_SHARED_CACHE
   int nTableLock;        /* Number of locks in aTableLock */
   TableLock *aTableLock; /* Required table locks for shared-cache mode */

@@ -11492,6 +11809,8 @@ struct Parse {

   /* Information used while coding trigger programs. */
   Parse *pToplevel;    /* Parse structure for main program (or NULL) */
   Table *pTriggerTab;  /* Table triggers are being coded for */
   int addrCrTab;       /* Address of OP_CreateTable opcode on CREATE TABLE */
   int addrSkipPK;      /* Address of instruction to skip PRIMARY KEY index */
   u32 nQueryLoop;      /* Est number of iterations of a query (10*log2(N)) */
   u32 oldmask;         /* Mask of old.* columns referenced */
   u32 newmask;         /* Mask of new.* columns referenced */

@@ -11499,11 +11818,17 @@ struct Parse {

   u8 eOrconf;          /* Default ON CONFLICT policy for trigger steps */
   u8 disableTriggers;  /* True to disable triggers */
   /* Above is constant between recursions.  Below is reset before and after
   ** each recursion */
   /************************************************************************
   ** Above is constant between recursions.  Below is reset before and after
   ** each recursion.  The boundary between these two regions is determined
   ** using offsetof(Parse,nVar) so the nVar field must be the first field
   ** in the recursive region.
   ************************************************************************/
   int nVar;                 /* Number of '?' variables seen in the SQL so far */
   int nzVar;                /* Number of available slots in azVar[] */
   u8 iPkSortOrder;          /* ASC or DESC for INTEGER PRIMARY KEY */
   u8 bFreeWith;             /* True if pWith should be freed with parser */
   u8 explain;               /* True if the EXPLAIN flag is found on the query */
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   u8 declareVtab;           /* True if inside sqlite3_declare_vtab() */

@@ -11517,7 +11842,6 @@ struct Parse {

 #endif
   char **azVar;             /* Pointers to names of parameters */
   Vdbe *pReprepare;         /* VM being reprepared (sqlite3Reprepare()) */
   int *aAlias;              /* Register used to hold aliased result */
   const char *zTail;        /* All SQL text past the last semicolon parsed */
   Table *pNewTable;         /* A table being constructed by CREATE TABLE */
   Trigger *pNewTrigger;     /* Trigger under construct by a CREATE TRIGGER */

@@ -11530,6 +11854,7 @@ struct Parse {

 #endif
   Table *pZombieTab;        /* List of Table objects to delete after code gen */
   TriggerPrg *pTriggerPrg;  /* Linked list of coded triggers */
   With *pWith;              /* Current WITH clause, or NULL */
 };
 /*

@@ -11649,7 +11974,7 @@ struct TriggerStep {

   Select *pSelect;     /* SELECT statment or RHS of INSERT INTO .. SELECT ... */
   Token target;        /* Target table for DELETE, UPDATE, INSERT */
   Expr *pWhere;        /* The WHERE clause for DELETE or UPDATE steps */
   ExprList *pExprList; /* SET clause for UPDATE.  VALUES clause for INSERT */
   ExprList *pExprList; /* SET clause for UPDATE. */
   IdList *pIdList;     /* Column names for INSERT */
   TriggerStep *pNext;  /* Next in the link-list */
   TriggerStep *pLast;  /* Last element in link-list. Valid for 1st elem only */

@@ -11710,6 +12035,7 @@ struct Sqlite3Config {

   int bOpenUri;                     /* True to interpret filenames as URIs */
   int bUseCis;                      /* Use covering indices for full-scans */
   int mxStrlen;                     /* Maximum string length */
   int neverCorrupt;                 /* Database is always well-formed */
   int szLookaside;                  /* Default lookaside buffer size */
   int nLookaside;                   /* Default lookaside buffer count */
   sqlite3_mem_methods m;            /* Low-level memory allocation interface */

@@ -11744,17 +12070,42 @@ struct Sqlite3Config {

   void(*xSqllog)(void*,sqlite3*,const char*, int);
   void *pSqllogArg;
 #endif
 #ifdef SQLITE_VDBE_COVERAGE
   /* The following callback (if not NULL) is invoked on every VDBE branch
   ** operation.  Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE.
   */
   void (*xVdbeBranch)(void*,int iSrcLine,u8 eThis,u8 eMx);  /* Callback */
   void *pVdbeBranchArg;                                     /* 1st argument */
 #endif
 };
 /*
 ** This macro is used inside of assert() statements to indicate that
 ** the assert is only valid on a well-formed database.  Instead of:
 **
 **     assert( X );
 **
 ** One writes:
 **
 **     assert( X || CORRUPT_DB );
 **
 ** CORRUPT_DB is true during normal operation.  CORRUPT_DB does not indicate
 ** that the database is definitely corrupt, only that it might be corrupt.
 ** For most test cases, CORRUPT_DB is set to false using a special
 ** sqlite3_test_control().  This enables assert() statements to prove
 ** things that are always true for well-formed databases.
 */
 #define CORRUPT_DB  (sqlite3Config.neverCorrupt==0)
 /*
 ** Context pointer passed down through the tree-walk.
 */
 struct Walker {
   int (*xExprCallback)(Walker*, Expr*);     /* Callback for expressions */
   int (*xSelectCallback)(Walker*,Select*);  /* Callback for SELECTs */
   void (*xSelectCallback2)(Walker*,Select*);/* Second callback for SELECTs */
   Parse *pParse;                            /* Parser context.  */
   int walkerDepth;                          /* Number of subqueries */
   u8 bSelectDepthFirst;                     /* Do subqueries first */
   union {                                   /* Extra data for callback */
     NameContext *pNC;                          /* Naming context */
     int i;                                     /* Integer value */

@@ -11779,6 +12130,21 @@ SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker*, Select*);

 #define WRC_Abort       2   /* Abandon the tree walk */
 /*
 ** An instance of this structure represents a set of one or more CTEs
 ** (common table expressions) created by a single WITH clause.
 */
 struct With {
   int nCte;                       /* Number of CTEs in the WITH clause */
   With *pOuter;                   /* Containing WITH clause, or NULL */
   struct Cte {                    /* For each CTE in the WITH clause.... */
     char *zName;                    /* Name of this CTE */
     ExprList *pCols;                /* List of explicit column names, or NULL */
     Select *pSelect;                /* The definition of this CTE */
     const char *zErr;               /* Error message for circular references */
   } a[1];
 };
 /*
 ** Assuming zIn points to the first byte of a UTF-8 character,
 ** advance zIn to point to the first byte of the next UTF-8 character.
 */

@@ -11917,10 +12283,20 @@ SQLITE_PRIVATE int sqlite3IsNaN(double);

 # define sqlite3IsNaN(X)  0
 #endif
 SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, int, const char*, va_list);
 #ifndef SQLITE_OMIT_TRACE
 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, const char*, ...);
 #endif
 /*
 ** An instance of the following structure holds information about SQL
 ** functions arguments that are the parameters to the printf() function.
 */
 struct PrintfArguments {
   int nArg;                /* Total number of arguments */
   int nUsed;               /* Number of arguments used so far */
   sqlite3_value **apArg;   /* The argument values */
 };
 #define SQLITE_PRINTF_INTERNAL 0x01
 #define SQLITE_PRINTF_SQLFUNC  0x02
 SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, u32, const char*, va_list);
 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, u32, const char*, ...);
 SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3*,const char*, ...);
 SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
 SQLITE_PRIVATE char *sqlite3MAppendf(sqlite3*,char*,const char*,...);

@@ -11986,6 +12362,8 @@ SQLITE_PRIVATE void sqlite3BeginParse(Parse*,int);

 SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
 SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*);
 SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *, int);
 SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table*);
 SQLITE_PRIVATE i16 sqlite3ColumnOfIndex(Index*, i16);
 SQLITE_PRIVATE void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int);
 SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token*);
 SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int);

@@ -11994,7 +12372,7 @@ SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*);

 SQLITE_PRIVATE void sqlite3AddColumnType(Parse*,Token*);
 SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,ExprSpan*);
 SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*);
 SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,Select*);
 SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,u8,Select*);
 SQLITE_PRIVATE int sqlite3ParseUri(const char*,const char*,unsigned int*,
                     sqlite3_vfs**,char**,char **);
 SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(sqlite3*,const char*);

@@ -12032,8 +12410,7 @@ SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse);

 # define sqlite3AutoincrementBegin(X)
 # define sqlite3AutoincrementEnd(X)
 #endif
 SQLITE_PRIVATE int sqlite3CodeCoroutine(Parse*, Select*, SelectDest*);
 SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);
 SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, Select*, IdList*, int);
 SQLITE_PRIVATE void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*);
 SQLITE_PRIVATE IdList *sqlite3IdListAppend(sqlite3*, IdList*, Token*);
 SQLITE_PRIVATE int sqlite3IdListIndex(IdList*,const char*);

@@ -12047,6 +12424,7 @@ SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList*);

 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*);
 SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*);
 SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3*, SrcList*);
 SQLITE_PRIVATE Index *sqlite3AllocateIndexObject(sqlite3*,i16,int,char**);
 SQLITE_PRIVATE Index *sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
                           Expr*, int, int);
 SQLITE_PRIVATE void sqlite3DropIndex(Parse*, SrcList*, int);

@@ -12069,7 +12447,7 @@ SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo*);

 SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo*, int*);
 SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int, u8);
 SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int);
 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int);

@@ -12079,12 +12457,15 @@ SQLITE_PRIVATE void sqlite3ExprCachePop(Parse*, int);

 SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse*, int, int);
 SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse*);
 SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse*, int, int);
 SQLITE_PRIVATE int sqlite3ExprCode(Parse*, Expr*, int);
 SQLITE_PRIVATE void sqlite3ExprCode(Parse*, Expr*, int);
 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse*, Expr*, int);
 SQLITE_PRIVATE void sqlite3ExprCodeAtInit(Parse*, Expr*, int, u8);
 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse*, Expr*, int*);
 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse*, Expr*, int);
 SQLITE_PRIVATE int sqlite3ExprCodeAndCache(Parse*, Expr*, int);
 SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse*, Expr*);
 SQLITE_PRIVATE int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int);
 SQLITE_PRIVATE void sqlite3ExprCodeAndCache(Parse*, Expr*, int);
 SQLITE_PRIVATE int sqlite3ExprCodeExprList(Parse*, ExprList*, int, u8);
 #define SQLITE_ECEL_DUP      0x01  /* Deep, not shallow copies */
 #define SQLITE_ECEL_FACTOR   0x02  /* Factor out constant terms */
 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse*, Expr*, int, int);
 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse*, Expr*, int, int);
 SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3*,const char*, const char*);

@@ -12105,7 +12486,6 @@ SQLITE_PRIVATE int sqlite3FunctionUsesThisSrc(Expr*, SrcList*);

 SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*);
 SQLITE_PRIVATE void sqlite3PrngSaveState(void);
 SQLITE_PRIVATE void sqlite3PrngRestoreState(void);
 SQLITE_PRIVATE void sqlite3PrngResetState(void);
 SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3*,int);
 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse*, int);
 SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb);

@@ -12120,20 +12500,21 @@ SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*);

 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*);
 SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr*, int*);
 SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*);
 SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(Vdbe*, const Expr*, int, int);
 SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char);
 SQLITE_PRIVATE int sqlite3IsRowid(const char*);
 SQLITE_PRIVATE void sqlite3GenerateRowDelete(Parse*, Table*, int, int, int, Trigger *, int);
 SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int*);
 SQLITE_PRIVATE int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*);
 SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int,int,
                                      int*,int,int,int,int,int*);
 SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*, Table*, int, int, int*, int, int, int);
 SQLITE_PRIVATE int sqlite3OpenTableAndIndices(Parse*, Table*, int, int);
 SQLITE_PRIVATE void sqlite3GenerateRowDelete(Parse*,Table*,Trigger*,int,int,int,i16,u8,u8,u8);
 SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int, int*);
 SQLITE_PRIVATE int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*,Index*,int);
 SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int,
                                      u8,u8,int,int*);
 SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*,Table*,int,int,int,int*,int,int,int);
 SQLITE_PRIVATE int sqlite3OpenTableAndIndices(Parse*, Table*, int, int, u8*, int*, int*);
 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int);
 SQLITE_PRIVATE void sqlite3MultiWrite(Parse*);
 SQLITE_PRIVATE void sqlite3MayAbort(Parse*);
 SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, int, char*, int);
 SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, int, char*, i8, u8);
 SQLITE_PRIVATE void sqlite3UniqueConstraint(Parse*, int, Index*);
 SQLITE_PRIVATE void sqlite3RowidConstraint(Parse*, int, Table*);
 SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,Expr*,int);
 SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,ExprList*,int);
 SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,SrcList*,int);

@@ -12167,7 +12548,7 @@ SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, i

 SQLITE_PRIVATE   void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*);
 SQLITE_PRIVATE   TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*);
 SQLITE_PRIVATE   TriggerStep *sqlite3TriggerInsertStep(sqlite3*,Token*, IdList*,
                                         ExprList*,Select*,u8);
                                         Select*,u8);
 SQLITE_PRIVATE   TriggerStep *sqlite3TriggerUpdateStep(sqlite3*,Token*,ExprList*, Expr*, u8);
 SQLITE_PRIVATE   TriggerStep *sqlite3TriggerDeleteStep(sqlite3*,Token*, Expr*);
 SQLITE_PRIVATE   void sqlite3DeleteTrigger(sqlite3*, Trigger*);

@@ -12262,7 +12643,7 @@ SQLITE_PRIVATE int sqlite3VarintLen(u64 v);

 SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *, Index *);
 SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *, Table *);
 SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe*, Table*, int);
 SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2);
 SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
 SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr);

@@ -12272,8 +12653,7 @@ SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);

 SQLITE_PRIVATE u8 sqlite3HexToInt(int h);
 SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) || \
     defined(SQLITE_DEBUG_OS_TRACE)
 #if defined(SQLITE_TEST)
 SQLITE_PRIVATE const char *sqlite3ErrName(int);
 #endif

@@ -12303,6 +12683,7 @@ SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8);

 SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8);
 SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
                         void(*)(void*));
 SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value*);
 SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*);
 SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *);
 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8);

@@ -12351,8 +12732,13 @@ SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse*, int, int);

 SQLITE_PRIVATE void sqlite3SchemaClear(void *);
 SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
 SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3*,int);
 SQLITE_PRIVATE KeyInfo *sqlite3IndexKeyinfo(Parse *, Index *);
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3*,int,int);
 SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo*);
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo*);
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*);
 #ifdef SQLITE_DEBUG
 SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo*);
 #endif
 SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
   void (*)(sqlite3_context*,int,sqlite3_value **),
   void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*),

@@ -12363,6 +12749,7 @@ SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *);

 SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, char*, int, int);
 SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum*,const char*,int);
 SQLITE_PRIVATE void sqlite3StrAccumAppendAll(StrAccum*,const char*);
 SQLITE_PRIVATE void sqlite3AppendSpace(StrAccum*,int);
 SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*);
 SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum*);

@@ -12444,6 +12831,7 @@ SQLITE_PRIVATE void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**)

 SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*);
 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
 SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
 SQLITE_PRIVATE void sqlite3ParserReset(Parse*);
 SQLITE_PRIVATE int sqlite3Reprepare(Vdbe*);
 SQLITE_PRIVATE void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*);
 SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq(Parse *, Expr *, Expr *);

@@ -12453,6 +12841,14 @@ SQLITE_PRIVATE const char *sqlite3JournalModename(int);

 SQLITE_PRIVATE   int sqlite3Checkpoint(sqlite3*, int, int, int*, int*);
 SQLITE_PRIVATE   int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int);
 #endif
 #ifndef SQLITE_OMIT_CTE
 SQLITE_PRIVATE   With *sqlite3WithAdd(Parse*,With*,Token*,ExprList*,Select*);
 SQLITE_PRIVATE   void sqlite3WithDelete(sqlite3*,With*);
 SQLITE_PRIVATE   void sqlite3WithPush(Parse*, With*, u8);
 #else
 #define sqlite3WithPush(x,y,z)
 #define sqlite3WithDelete(x,y)
 #endif
 /* Declarations for functions in fkey.c. All of these are replaced by
 ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign

@@ -12760,6 +13156,7 @@ SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = {

    SQLITE_USE_URI,            /* bOpenUri */
    SQLITE_ALLOW_COVERING_INDEX_SCAN,   /* bUseCis */
 x7ffffffe,                /* mxStrlen */
 ,                         /* neverCorrupt */
 ,                       /* szLookaside */
 ,                       /* nLookaside */
    {0,0,0,0,0,0,0,0},         /* m */

@@ -12795,7 +13192,6 @@ SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = {

 #endif
 };
 /*
 ** Hash table for global functions - functions common to all
 ** database connections.  After initialization, this table is

@@ -13060,6 +13456,9 @@ static const char * const azCompileOpt[] = {

 #ifdef SQLITE_OMIT_COMPOUND_SELECT
   "OMIT_COMPOUND_SELECT",
 #endif
 #ifdef SQLITE_OMIT_CTE
   "OMIT_CTE",
 #endif
 #ifdef SQLITE_OMIT_DATETIME_FUNCS
   "OMIT_DATETIME_FUNCS",
 #endif

@@ -13192,6 +13591,9 @@ static const char * const azCompileOpt[] = {

 #ifdef SQLITE_SOUNDEX
   "SOUNDEX",
 #endif
 #ifdef SQLITE_SYSTEM_MALLOC
   "SYSTEM_MALLOC",
 #endif
 #ifdef SQLITE_TCL
   "TCL",
 #endif

@@ -13207,6 +13609,9 @@ static const char * const azCompileOpt[] = {

 #ifdef SQLITE_USE_ALLOCA
   "USE_ALLOCA",
 #endif
 #ifdef SQLITE_WIN32_MALLOC
   "WIN32_MALLOC",
 #endif
 #ifdef SQLITE_ZERO_MALLOC
   "ZERO_MALLOC"
 #endif

@@ -13306,7 +13711,7 @@ typedef struct VdbeOp Op;

 /*
 ** Boolean values
 */
 typedef unsigned char Bool;
 typedef unsigned Bool;
 /* Opaque type used by code in vdbesort.c */
 typedef struct VdbeSorter VdbeSorter;

@@ -13323,6 +13728,9 @@ typedef struct AuxData AuxData;

 ** loop over all entries of the Btree.  You can also insert new BTree
 ** entries or retrieve the key or data from the entry that the cursor
 ** is currently pointing to.
 **
 ** Cursors can also point to virtual tables, sorters, or "pseudo-tables".
 ** A pseudo-table is a single-row table implemented by registers.
 **
 ** Every cursor that the virtual machine has open is represented by an
 ** instance of the following structure.

@@ -13331,31 +13739,23 @@ struct VdbeCursor {

   BtCursor *pCursor;    /* The cursor structure of the backend */
   Btree *pBt;           /* Separate file holding temporary table */
   KeyInfo *pKeyInfo;    /* Info about index keys needed by index cursors */
   int iDb;              /* Index of cursor database in db->aDb[] (or -1) */
   int seekResult;       /* Result of previous sqlite3BtreeMoveto() */
   int pseudoTableReg;   /* Register holding pseudotable content. */
   int nField;           /* Number of fields in the header */
   Bool zeroed;          /* True if zeroed out and ready for reuse */
   Bool rowidIsValid;    /* True if lastRowid is valid */
   Bool atFirst;         /* True if pointing to first entry */
   Bool useRandomRowid;  /* Generate new record numbers semi-randomly */
   Bool nullRow;         /* True if pointing to a row with no data */
   Bool deferredMoveto;  /* A call to sqlite3BtreeMoveto() is needed */
   Bool isTable;         /* True if a table requiring integer keys */
   Bool isIndex;         /* True if an index containing keys only - no data */
   Bool isOrdered;       /* True if the underlying table is BTREE_UNORDERED */
   Bool isSorter;        /* True if a new-style sorter */
   Bool multiPseudo;     /* Multi-register pseudo-cursor */
   i16 nField;           /* Number of fields in the header */
   u16 nHdrParsed;       /* Number of header fields parsed so far */
   i8 iDb;               /* Index of cursor database in db->aDb[] (or -1) */
   u8 nullRow;           /* True if pointing to a row with no data */
   u8 rowidIsValid;      /* True if lastRowid is valid */
   u8 deferredMoveto;    /* A call to sqlite3BtreeMoveto() is needed */
   Bool useRandomRowid:1;/* Generate new record numbers semi-randomly */
   Bool isTable:1;       /* True if a table requiring integer keys */
   Bool isOrdered:1;     /* True if the underlying table is BTREE_UNORDERED */
   sqlite3_vtab_cursor *pVtabCursor;  /* The cursor for a virtual table */
   const sqlite3_module *pModule;     /* Module for cursor pVtabCursor */
   i64 seqCount;         /* Sequence counter */
   i64 movetoTarget;     /* Argument to the deferred sqlite3BtreeMoveto() */
   i64 lastRowid;        /* Last rowid from a Next or NextIdx operation */
   i64 lastRowid;        /* Rowid being deleted by OP_Delete */
   VdbeSorter *pSorter;  /* Sorter object for OP_SorterOpen cursors */
   /* Result of last sqlite3BtreeMoveto() done by an OP_NotExists or
   ** OP_IsUnique opcode on this cursor. */
   int seekResult;
   /* Cached information about the header for the data record that the
   ** cursor is currently pointing to.  Only valid if cacheStatus matches
   ** Vdbe.cacheCtr.  Vdbe.cacheCtr will never take on the value of

@@ -13366,10 +13766,14 @@ struct VdbeCursor {

   ** be NULL.
   */
   u32 cacheStatus;      /* Cache is valid if this matches Vdbe.cacheCtr */
   int payloadSize;      /* Total number of bytes in the record */
   u32 *aType;           /* Type values for all entries in the record */
   u32 *aOffset;         /* Cached offsets to the start of each columns data */
   u8 *aRow;             /* Data for the current row, if all on one page */
   u32 payloadSize;      /* Total number of bytes in the record */
   u32 szRow;            /* Byte available in aRow */
   u32 iHdrOffset;       /* Offset to next unparsed byte of the header */
   const u8 *aRow;       /* Data for the current row, if all on one page */
   u32 aType[1];         /* Type values for all entries in the record */
   /* 2*nField extra array elements allocated for aType[], beyond the one
   ** static element declared in the structure.  nField total array slots for
   ** aType[] and nField+1 array slots for aOffset[] */
 };
 typedef struct VdbeCursor VdbeCursor;

@@ -13439,7 +13843,6 @@ struct Mem {

   } u;
   int n;              /* Number of characters in string value, excluding '\0' */
   u16 flags;          /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
   u8  type;           /* One of SQLITE_NULL, SQLITE_TEXT, SQLITE_INTEGER, etc */
   u8  enc;            /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
 #ifdef SQLITE_DEBUG
   Mem *pScopyFrom;    /* This Mem is a shallow copy of pScopyFrom */

@@ -13466,9 +13869,10 @@ struct Mem {

 #define MEM_Int       0x0004   /* Value is an integer */
 #define MEM_Real      0x0008   /* Value is a real number */
 #define MEM_Blob      0x0010   /* Value is a BLOB */
 #define MEM_AffMask   0x001f   /* Mask of affinity bits */
 #define MEM_RowSet    0x0020   /* Value is a RowSet object */
 #define MEM_Frame     0x0040   /* Value is a VdbeFrame object */
 #define MEM_Invalid   0x0080   /* Value is undefined */
 #define MEM_Undefined 0x0080   /* Value is undefined */
 #define MEM_Cleared   0x0100   /* NULL set by OP_Null, not from data */
 #define MEM_TypeMask  0x01ff   /* Mask of type bits */

@@ -13479,7 +13883,7 @@ struct Mem {

 ** string is \000 or \u0000 terminated
 */
 #define MEM_Term      0x0200   /* String rep is nul terminated */
 #define MEM_Dyn       0x0400   /* Need to call sqliteFree() on Mem.z */
 #define MEM_Dyn       0x0400   /* Need to call Mem.xDel() on Mem.z */
 #define MEM_Static    0x0800   /* Mem.z points to a static string */
 #define MEM_Ephem     0x1000   /* Mem.z points to an ephemeral string */
 #define MEM_Agg       0x2000   /* Mem.z points to an agg function context */

@@ -13500,7 +13904,7 @@ struct Mem {

 ** is for use inside assert() statements only.
 */
 #ifdef SQLITE_DEBUG
 #define memIsValid(M)  ((M)->flags & MEM_Invalid)==0
 #define memIsValid(M)  ((M)->flags & MEM_Undefined)==0
 #endif
 /*

@@ -13582,12 +13986,9 @@ struct Vdbe {

   Mem **apArg;            /* Arguments to currently executing user function */
   Mem *aColName;          /* Column names to return */
   Mem *pResultSet;        /* Pointer to an array of results */
   Parse *pParse;          /* Parsing context used to create this Vdbe */
   int nMem;               /* Number of memory locations currently allocated */
   int nOp;                /* Number of instructions in the program */
   int nOpAlloc;           /* Number of slots allocated for aOp[] */
   int nLabel;             /* Number of labels used */
   int *aLabel;            /* Space to hold the labels */
   u16 nResColumn;         /* Number of columns in one row of the result set */
   int nCursor;            /* Number of slots in apCsr[] */
   u32 magic;              /* Magic number for sanity checking */
   char *zErrMsg;          /* Error message written here */

@@ -13600,6 +14001,7 @@ struct Vdbe {

   u32 cacheCtr;           /* VdbeCursor row cache generation counter */
   int pc;                 /* The program counter */
   int rc;                 /* Value to return */
   u16 nResColumn;         /* Number of columns in one row of the result set */
   u8 errorAction;         /* Recovery action to do in case of an error */
   u8 minWriteFileFormat;  /* Minimum file format for writable database files */
   bft explain:2;          /* True if EXPLAIN present on SQL command */

@@ -13626,9 +14028,6 @@ struct Vdbe {

   i64 nStmtDefImmCons;    /* Number of def. imm constraints when stmt started */
   char *zSql;             /* Text of the SQL statement that generated this */
   void *pFree;            /* Free this when deleting the vdbe */
 #ifdef SQLITE_DEBUG
   FILE *trace;            /* Write an execution trace here, if not NULL */
 #endif
 #ifdef SQLITE_ENABLE_TREE_EXPLAIN
   Explain *pExplain;      /* The explainer */
   char *zExplain;         /* Explanation of data structures */

@@ -13662,12 +14061,12 @@ SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, Op*);

 #endif
 SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32);
 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int);
 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, int, Mem*, int);
 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, Mem*, u32);
 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
 SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(Vdbe*, int, int);
 int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
 SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(VdbeCursor*,UnpackedRecord*,int*);
 SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(VdbeCursor*,const UnpackedRecord*,int*);
 SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3*, BtCursor *, i64 *);
 SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
 SQLITE_PRIVATE int sqlite3VdbeExec(Vdbe*);

@@ -13697,19 +14096,19 @@ SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*);

 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,int,Mem*);
 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p);
 #define VdbeMemDynamic(X)  \
   (((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))!=0)
 #define VdbeMemRelease(X)  \
   if((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame)) \
     sqlite3VdbeMemReleaseExternal(X);
   if( VdbeMemDynamic(X) ) sqlite3VdbeMemReleaseExternal(X);
 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
 SQLITE_PRIVATE const char *sqlite3OpcodeName(int);
 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
 SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int);
 SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*);
 SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *);
 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem);
 SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p);
 SQLITE_PRIVATE int sqlite3VdbeSorterInit(sqlite3 *, VdbeCursor *);

@@ -13718,7 +14117,7 @@ SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *, Mem *);

 SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *, const VdbeCursor *, int *);
 SQLITE_PRIVATE int sqlite3VdbeSorterRewind(sqlite3 *, const VdbeCursor *, int *);
 SQLITE_PRIVATE int sqlite3VdbeSorterWrite(sqlite3 *, const VdbeCursor *, Mem *);
 SQLITE_PRIVATE int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int *);
 SQLITE_PRIVATE int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *);
 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
 SQLITE_PRIVATE   void sqlite3VdbeEnter(Vdbe*);

@@ -13730,6 +14129,7 @@ SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe*);

 #ifdef SQLITE_DEBUG
 SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
 SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem*);
 #endif
 #ifndef SQLITE_OMIT_FOREIGN_KEY

@@ -15252,7 +15652,21 @@ SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){

 ** routine has no return value since the return value would be meaningless.
 */
 SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
   DO_OS_MALLOC_TEST(id);
 #ifdef SQLITE_TEST
   if( op!=SQLITE_FCNTL_COMMIT_PHASETWO ){
     /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite
     ** is using a regular VFS, it is called after the corresponding
     ** transaction has been committed. Injecting a fault at this point
     ** confuses the test scripts - the COMMIT comand returns SQLITE_NOMEM
     ** but the transaction is committed anyway.
     **
     ** The core must call OsFileControl() though, not OsFileControlHint(),
     ** as if a custom VFS (e.g. zipvfs) returns an error here, it probably
     ** means the commit really has failed and an error should be returned
     ** to the user.  */
     DO_OS_MALLOC_TEST(id);
   }
 #endif
   return id->pMethods->xFileControl(id, op, pArg);
 }
 SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){

@@ -15722,16 +16136,6 @@ SQLITE_PRIVATE void sqlite3MemSetDefault(void){

 ** macros.
 */
 #ifdef SQLITE_SYSTEM_MALLOC
 /*
 ** The MSVCRT has malloc_usable_size() but it is called _msize().
 ** The use of _msize() is automatic, but can be disabled by compiling
 ** with -DSQLITE_WITHOUT_MSIZE
 */
 #if defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE)
 # define SQLITE_MALLOCSIZE _msize
 #endif
 #if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
 /*

@@ -15754,22 +16158,48 @@ static malloc_zone_t* _sqliteZone_;

 ** Use standard C library malloc and free on non-Apple systems.
 ** Also used by Apple systems if SQLITE_WITHOUT_ZONEMALLOC is defined.
 */
 #define SQLITE_MALLOC(x)    malloc(x)
 #define SQLITE_FREE(x)      free(x)
 #define SQLITE_REALLOC(x,y) realloc((x),(y))
 #define SQLITE_MALLOC(x)             malloc(x)
 #define SQLITE_FREE(x)               free(x)
 #define SQLITE_REALLOC(x,y)          realloc((x),(y))
 #if (defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE)) \
       || (defined(HAVE_MALLOC_H) && defined(HAVE_MALLOC_USABLE_SIZE))
 # include <malloc.h>    /* Needed for malloc_usable_size on linux */
 #endif
 #ifdef HAVE_MALLOC_USABLE_SIZE
 # ifndef SQLITE_MALLOCSIZE
 #  define SQLITE_MALLOCSIZE(x) malloc_usable_size(x)
 # endif
 #else
 # undef SQLITE_MALLOCSIZE
 /*
 ** The malloc.h header file is needed for malloc_usable_size() function
 ** on some systems (e.g. Linux).
 */
 #if defined(HAVE_MALLOC_H) && defined(HAVE_MALLOC_USABLE_SIZE)
 #  define SQLITE_USE_MALLOC_H
 #  define SQLITE_USE_MALLOC_USABLE_SIZE
 /*
 ** The MSVCRT has malloc_usable_size(), but it is called _msize().  The
 ** use of _msize() is automatic, but can be disabled by compiling with
 ** -DSQLITE_WITHOUT_MSIZE.  Using the _msize() function also requires
 ** the malloc.h header file.
 */
 #elif defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE)
 #  define SQLITE_USE_MALLOC_H
 #  define SQLITE_USE_MSIZE
 #endif
 /*
 ** Include the malloc.h header file, if necessary.  Also set define macro
 ** SQLITE_MALLOCSIZE to the appropriate function name, which is _msize()
 ** for MSVC and malloc_usable_size() for most other systems (e.g. Linux).
 ** The memory size function can always be overridden manually by defining
 ** the macro SQLITE_MALLOCSIZE to the desired function name.
 */
 #if defined(SQLITE_USE_MALLOC_H)
 #  include <malloc.h>
 #  if defined(SQLITE_USE_MALLOC_USABLE_SIZE)
 #    if !defined(SQLITE_MALLOCSIZE)
 #      define SQLITE_MALLOCSIZE(x)   malloc_usable_size(x)
 #    endif
 #  elif defined(SQLITE_USE_MSIZE)
 #    if !defined(SQLITE_MALLOCSIZE)
 #      define SQLITE_MALLOCSIZE      _msize
 #    endif
 #  endif
 #endif /* defined(SQLITE_USE_MALLOC_H) */
 #endif /* __APPLE__ or not __APPLE__ */
 /*

@@ -17375,7 +17805,7 @@ static void memsys5Leave(void){

 static int memsys5Size(void *p){
   int iSize = 0;
   if( p ){
     int i = ((u8 *)p-mem5.zPool)/mem5.szAtom;
     int i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom);
     assert( i>=0 && i<mem5.nBlock );
     iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE));
   }

@@ -17383,25 +17813,6 @@ static int memsys5Size(void *p){

 }
 /*
 ** Find the first entry on the freelist iLogsize.  Unlink that
 ** entry and return its index.
 */
 static int memsys5UnlinkFirst(int iLogsize){
   int i;
   int iFirst;
   assert( iLogsize>=0 && iLogsize<=LOGMAX );
   i = iFirst = mem5.aiFreelist[iLogsize];
   assert( iFirst>=0 );
   while( i>0 ){
     if( i<iFirst ) iFirst = i;
     i = MEM5LINK(i)->next;
   }
   memsys5Unlink(iFirst, iLogsize);
   return iFirst;
 }
 /*
 ** Return a block of memory of at least nBytes in size.
 ** Return NULL if unable.  Return NULL if nBytes==0.
 **

@@ -17446,7 +17857,8 @@ static void *memsys5MallocUnsafe(int nByte){

     sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte);
     return 0;
   }
   i = memsys5UnlinkFirst(iBin);
   i = mem5.aiFreelist[iBin];
   memsys5Unlink(i, iBin);
   while( iBin>iLogsize ){
     int newSize;

@@ -17466,6 +17878,12 @@ static void *memsys5MallocUnsafe(int nByte){

   if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
   if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
 #ifdef SQLITE_DEBUG
   /* Make sure the allocated memory does not assume that it is set to zero
   ** or retains a value from a previous allocation */
   memset(&mem5.zPool[i*mem5.szAtom], 0xAA, iFullSz);
 #endif
   /* Return a pointer to the allocated memory. */
   return (void*)&mem5.zPool[i*mem5.szAtom];
 }

@@ -17480,7 +17898,7 @@ static void memsys5FreeUnsafe(void *pOld){

   /* Set iBlock to the index of the block pointed to by pOld in
   ** the array of mem5.szAtom byte blocks pointed to by mem5.zPool.
   */
   iBlock = ((u8 *)pOld-mem5.zPool)/mem5.szAtom;
   iBlock = (int)(((u8 *)pOld-mem5.zPool)/mem5.szAtom);
   /* Check that the pointer pOld points to a valid, non-free block. */
   assert( iBlock>=0 && iBlock<mem5.nBlock );

@@ -17523,6 +17941,13 @@ static void memsys5FreeUnsafe(void *pOld){

     }
     size *= 2;
   }
 #ifdef SQLITE_DEBUG
   /* Overwrite freed memory with the 0x55 bit pattern to verify that it is
   ** not used after being freed */
   memset(&mem5.zPool[iBlock*mem5.szAtom], 0x55, size);
 #endif
   memsys5Link(iBlock, iLogsize);
 }

@@ -19249,7 +19674,7 @@ SQLITE_PRIVATE void sqlite3ScratchFree(void *p){

 */
 #ifndef SQLITE_OMIT_LOOKASIDE
 static int isLookaside(sqlite3 *db, void *p){
   return p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
   return p>=db->lookaside.pStart && p<db->lookaside.pEnd;
 }
 #else
 #define isLookaside(A,B) 0

@@ -19265,8 +19690,9 @@ SQLITE_PRIVATE int sqlite3MallocSize(void *p){

   return sqlite3GlobalConfig.m.xSize(p);
 }
 SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
   assert( db==0 || sqlite3_mutex_held(db->mutex) );
   if( db && isLookaside(db, p) ){
   assert( db!=0 );
   assert( sqlite3_mutex_held(db->mutex) );
   if( isLookaside(db, p) ){
     return db->lookaside.sz;
   }else{
     assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );

@@ -19750,6 +20176,31 @@ SQLITE_PRIVATE void sqlite3AppendSpace(StrAccum *pAccum, int N){

 }
 /*
 ** Set the StrAccum object to an error mode.
 */
 static void setStrAccumError(StrAccum *p, u8 eError){
   p->accError = eError;
   p->nAlloc = 0;
 }
 /*
 ** Extra argument values from a PrintfArguments object
 */
 static sqlite3_int64 getIntArg(PrintfArguments *p){
   if( p->nArg<=p->nUsed ) return 0;
   return sqlite3_value_int64(p->apArg[p->nUsed++]);
 }
 static double getDoubleArg(PrintfArguments *p){
   if( p->nArg<=p->nUsed ) return 0.0;
   return sqlite3_value_double(p->apArg[p->nUsed++]);
 }
 static char *getTextArg(PrintfArguments *p){
   if( p->nArg<=p->nUsed ) return 0;
   return (char*)sqlite3_value_text(p->apArg[p->nUsed++]);
 }
 /*
 ** On machines with a small stack size, you can redefine the
 ** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired.
 */

@@ -19762,10 +20213,10 @@ SQLITE_PRIVATE void sqlite3AppendSpace(StrAccum *pAccum, int N){

 ** Render a string given by "fmt" into the StrAccum object.
 */
 SQLITE_PRIVATE void sqlite3VXPrintf(
   StrAccum *pAccum,                  /* Accumulate results here */
   int useExtended,                   /* Allow extended %-conversions */
   const char *fmt,                   /* Format string */
   va_list ap                         /* arguments */
   StrAccum *pAccum,          /* Accumulate results here */
   u32 bFlags,                /* SQLITE_PRINTF_* flags */
   const char *fmt,           /* Format string */
   va_list ap                 /* arguments */
 ){
   int c;                     /* Next character in the format string */
   char *bufpt;               /* Pointer to the conversion buffer */

@@ -19783,6 +20234,8 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

   etByte flag_longlong;      /* True if the "ll" flag is present */
   etByte done;               /* Loop termination flag */
   etByte xtype = 0;          /* Conversion paradigm */
   u8 bArgList;               /* True for SQLITE_PRINTF_SQLFUNC */
   u8 useIntern;              /* Ok to use internal conversions (ex: %T) */
   char prefix;               /* Prefix character.  "+" or "-" or " " or '\0'. */
   sqlite_uint64 longvalue;   /* Value for integer types */
   LONGDOUBLE_TYPE realvalue; /* Value for real types */

@@ -19797,9 +20250,18 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

   etByte flag_dp;            /* True if decimal point should be shown */
   etByte flag_rtz;           /* True if trailing zeros should be removed */
 #endif
   PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */
   char buf[etBUFSIZE];       /* Conversion buffer */
   bufpt = 0;
   if( bFlags ){
     if( (bArgList = (bFlags & SQLITE_PRINTF_SQLFUNC))!=0 ){
       pArgList = va_arg(ap, PrintfArguments*);
     }
     useIntern = bFlags & SQLITE_PRINTF_INTERNAL;
   }else{
     bArgList = useIntern = 0;
   }
   for(; (c=(*fmt))!=0; ++fmt){
     if( c!='%' ){
       int amt;

@@ -19831,7 +20293,11 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

     /* Get the field width */
     width = 0;
     if( c=='*' ){
       width = va_arg(ap,int);
       if( bArgList ){
         width = (int)getIntArg(pArgList);
       }else{
         width = va_arg(ap,int);
       }
       if( width<0 ){
         flag_leftjustify = 1;
         width = -width;

@@ -19848,7 +20314,11 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

       precision = 0;
       c = *++fmt;
       if( c=='*' ){
         precision = va_arg(ap,int);
         if( bArgList ){
           precision = (int)getIntArg(pArgList);
         }else{
           precision = va_arg(ap,int);
         }
         if( precision<0 ) precision = -precision;
         c = *++fmt;
       }else{

@@ -19879,7 +20349,7 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

     for(idx=0; idx<ArraySize(fmtinfo); idx++){
       if( c==fmtinfo[idx].fmttype ){
         infop = &fmtinfo[idx];
         if( useExtended || (infop->flags & FLAG_INTERN)==0 ){
         if( useIntern || (infop->flags & FLAG_INTERN)==0 ){
           xtype = infop->type;
         }else{
           return;

@@ -19919,7 +20389,9 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

       case etRADIX:
         if( infop->flags & FLAG_SIGNED ){
           i64 v;
           if( flag_longlong ){
           if( bArgList ){
             v = getIntArg(pArgList);
           }else if( flag_longlong ){
             v = va_arg(ap,i64);
           }else if( flag_long ){
             v = va_arg(ap,long int);

@@ -19940,7 +20412,9 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

             else                       prefix = 0;
           }
         }else{
           if( flag_longlong ){
           if( bArgList ){
             longvalue = (u64)getIntArg(pArgList);
           }else if( flag_longlong ){
             longvalue = va_arg(ap,u64);
           }else if( flag_long ){
             longvalue = va_arg(ap,unsigned long int);

@@ -19960,7 +20434,7 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

           nOut = precision + 10;
           zOut = zExtra = sqlite3Malloc( nOut );
           if( zOut==0 ){
             pAccum->accError = STRACCUM_NOMEM;
             setStrAccumError(pAccum, STRACCUM_NOMEM);
             return;
           }
         }

@@ -20000,7 +20474,11 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

       case etFLOAT:
       case etEXP:
       case etGENERIC:
         realvalue = va_arg(ap,double);
         if( bArgList ){
           realvalue = getDoubleArg(pArgList);
         }else{
           realvalue = va_arg(ap,double);
         }
 #ifdef SQLITE_OMIT_FLOATING_POINT
         length = 0;
 #else

@@ -20072,7 +20550,7 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

         if( MAX(e2,0)+precision+width > etBUFSIZE - 15 ){
           bufpt = zExtra = sqlite3Malloc( MAX(e2,0)+precision+width+15 );
           if( bufpt==0 ){
             pAccum->accError = STRACCUM_NOMEM;
             setStrAccumError(pAccum, STRACCUM_NOMEM);
             return;
           }
         }

@@ -20155,7 +20633,9 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

 #endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
         break;
       case etSIZE:
         *(va_arg(ap,int*)) = pAccum->nChar;
         if( !bArgList ){
           *(va_arg(ap,int*)) = pAccum->nChar;
         }
         length = width = 0;
         break;
       case etPERCENT:

@@ -20164,7 +20644,12 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

         length = 1;
         break;
       case etCHARX:
         c = va_arg(ap,int);
         if( bArgList ){
           bufpt = getTextArg(pArgList);
           c = bufpt ? bufpt[0] : 0;
         }else{
           c = va_arg(ap,int);
         }
         buf[0] = (char)c;
         if( precision>=0 ){
           for(idx=1; idx<precision; idx++) buf[idx] = (char)c;

@@ -20176,10 +20661,14 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

         break;
       case etSTRING:
       case etDYNSTRING:
         bufpt = va_arg(ap,char*);
         if( bArgList ){
           bufpt = getTextArg(pArgList);
         }else{
           bufpt = va_arg(ap,char*);
         }
         if( bufpt==0 ){
           bufpt = "";
         }else if( xtype==etDYNSTRING ){
         }else if( xtype==etDYNSTRING && !bArgList ){
           zExtra = bufpt;
         }
         if( precision>=0 ){

@@ -20195,7 +20684,13 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

         int needQuote;
         char ch;
         char q = ((xtype==etSQLESCAPE3)?'"':'\'');   /* Quote character */
         char *escarg = va_arg(ap,char*);
         char *escarg;
         if( bArgList ){
           escarg = getTextArg(pArgList);
         }else{
           escarg = va_arg(ap,char*);
         }
         isnull = escarg==0;
         if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
         k = precision;

@@ -20207,7 +20702,7 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

         if( n>etBUFSIZE ){
           bufpt = zExtra = sqlite3Malloc( n );
           if( bufpt==0 ){
             pAccum->accError = STRACCUM_NOMEM;
             setStrAccumError(pAccum, STRACCUM_NOMEM);
             return;
           }
         }else{

@@ -20230,7 +20725,8 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

       }
       case etTOKEN: {
         Token *pToken = va_arg(ap, Token*);
         if( pToken ){
         assert( bArgList==0 );
         if( pToken && pToken->n ){
           sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);
         }
         length = width = 0;

@@ -20240,12 +20736,13 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

         SrcList *pSrc = va_arg(ap, SrcList*);
         int k = va_arg(ap, int);
         struct SrcList_item *pItem = &pSrc->a[k];
         assert( bArgList==0 );
         assert( k>=0 && k<pSrc->nSrc );
         if( pItem->zDatabase ){
           sqlite3StrAccumAppend(pAccum, pItem->zDatabase, -1);
           sqlite3StrAccumAppendAll(pAccum, pItem->zDatabase);
           sqlite3StrAccumAppend(pAccum, ".", 1);
         }
         sqlite3StrAccumAppend(pAccum, pItem->zName, -1);
         sqlite3StrAccumAppendAll(pAccum, pItem->zName);
         length = width = 0;
         break;
       }

@@ -20276,7 +20773,7 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

         sqlite3AppendSpace(pAccum, nspace);
       }
     }
     sqlite3_free(zExtra);
     if( zExtra ) sqlite3_free(zExtra);
   }/* End for loop over the format string */
 } /* End of function */

@@ -20284,22 +20781,20 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

 ** Append N bytes of text from z to the StrAccum object.
 */
 SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
   assert( z!=0 || N==0 );
   if( p->accError ){
     testcase(p->accError==STRACCUM_TOOBIG);
     testcase(p->accError==STRACCUM_NOMEM);
     return;
   }
   assert( p->zText!=0 || p->nChar==0 );
   if( N<=0 ){
     if( N==0 || z[0]==0 ) return;
     N = sqlite3Strlen30(z);
   }
   assert( z!=0 );
   assert( p->zText!=0 || p->nChar==0 || p->accError );
   assert( N>=0 );
   assert( p->accError==0 || p->nAlloc==0 );
   if( p->nChar+N >= p->nAlloc ){
     char *zNew;
     if( p->accError ){
       testcase(p->accError==STRACCUM_TOOBIG);
       testcase(p->accError==STRACCUM_NOMEM);
       return;
     }
     if( !p->useMalloc ){
       p->accError = STRACCUM_TOOBIG;
       N = p->nAlloc - p->nChar - 1;
       setStrAccumError(p, STRACCUM_TOOBIG);
       if( N<=0 ){
         return;
       }

@@ -20309,7 +20804,7 @@ SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){

       szNew += N + 1;
       if( szNew > p->mxAlloc ){
         sqlite3StrAccumReset(p);
         p->accError = STRACCUM_TOOBIG;
         setStrAccumError(p, STRACCUM_TOOBIG);
         return;
       }else{
         p->nAlloc = (int)szNew;

@@ -20323,8 +20818,8 @@ SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){

         if( zOld==0 && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
         p->zText = zNew;
       }else{
         p->accError = STRACCUM_NOMEM;
         sqlite3StrAccumReset(p);
         setStrAccumError(p, STRACCUM_NOMEM);
         return;
       }
     }

@@ -20335,6 +20830,14 @@ SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){

 }
 /*
 ** Append the complete text of zero-terminated string z[] to the p string.
 */
 SQLITE_PRIVATE void sqlite3StrAccumAppendAll(StrAccum *p, const char *z){
   sqlite3StrAccumAppend(p, z, sqlite3Strlen30(z));
 }
 /*
 ** Finish off a string by making sure it is zero-terminated.
 ** Return a pointer to the resulting string.  Return a NULL
 ** pointer if any kind of error was encountered.

@@ -20351,7 +20854,7 @@ SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){

       if( p->zText ){
         memcpy(p->zText, p->zBase, p->nChar+1);
       }else{
         p->accError = STRACCUM_NOMEM;
         setStrAccumError(p, STRACCUM_NOMEM);
       }
     }
   }

@@ -20397,7 +20900,7 @@ SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list a

   sqlite3StrAccumInit(&acc, zBase, sizeof(zBase),
                       db->aLimit[SQLITE_LIMIT_LENGTH]);
   acc.db = db;
   sqlite3VXPrintf(&acc, 1, zFormat, ap);
   sqlite3VXPrintf(&acc, SQLITE_PRINTF_INTERNAL, zFormat, ap);
   z = sqlite3StrAccumFinish(&acc);
   if( acc.accError==STRACCUM_NOMEM ){
     db->mallocFailed = 1;

@@ -20553,17 +21056,15 @@ SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){

 }
 #endif
 #ifndef SQLITE_OMIT_TRACE
 /*
 ** variable-argument wrapper around sqlite3VXPrintf().
 */
 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, const char *zFormat, ...){
 SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, u32 bFlags, const char *zFormat, ...){
   va_list ap;
   va_start(ap,zFormat);
   sqlite3VXPrintf(p, 1, zFormat, ap);
   sqlite3VXPrintf(p, bFlags, zFormat, ap);
   va_end(ap);
 }
 #endif
 /************** End of printf.c **********************************************/
 /************** Begin file random.c ******************************************/

@@ -20620,6 +21121,12 @@ SQLITE_API void sqlite3_randomness(int N, void *pBuf){

   sqlite3_mutex_enter(mutex);
 #endif
   if( N<=0 ){
     wsdPrng.isInit = 0;
     sqlite3_mutex_leave(mutex);
     return;
   }
   /* Initialize the state of the random number generator once,
   ** the first time this routine is called.  The seed value does
   ** not need to contain a lot of randomness since we are not

@@ -20647,7 +21154,8 @@ SQLITE_API void sqlite3_randomness(int N, void *pBuf){

     wsdPrng.isInit = 1;
   }
   while( N-- ){
   assert( N>0 );
   do{
     wsdPrng.i++;
     t = wsdPrng.s[wsdPrng.i];
     wsdPrng.j += t;

@@ -20655,7 +21163,7 @@ SQLITE_API void sqlite3_randomness(int N, void *pBuf){

     wsdPrng.s[wsdPrng.j] = t;
     t += wsdPrng.s[wsdPrng.i];
     *(zBuf++) = wsdPrng.s[t];
   }
   }while( --N );
   sqlite3_mutex_leave(mutex);
 }

@@ -20684,9 +21192,6 @@ SQLITE_PRIVATE void sqlite3PrngRestoreState(void){

     sizeof(sqlite3Prng)
   );
 }
 SQLITE_PRIVATE void sqlite3PrngResetState(void){
   GLOBAL(struct sqlite3PrngType, sqlite3Prng).isInit = 0;
 }
 #endif /* SQLITE_OMIT_BUILTIN_TEST */
 /************** End of random.c **********************************************/

@@ -21008,7 +21513,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){

   sqlite3VdbeMemRelease(pMem);
   pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem);
   pMem->enc = desiredEnc;
   pMem->flags |= (MEM_Term|MEM_Dyn);
   pMem->flags |= (MEM_Term);
   pMem->z = (char*)zOut;
   pMem->zMalloc = pMem->z;

@@ -21136,7 +21641,6 @@ SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 e

   }
   assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
   assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
   assert( (m.flags & MEM_Dyn)!=0 || db->mallocFailed );
   assert( m.z || db->mallocFailed );
   return m.z;
 }

@@ -21338,18 +21842,17 @@ SQLITE_PRIVATE int sqlite3Strlen30(const char *z){

 ** to NULL.
 */
 SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
   if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
     db->errCode = err_code;
     if( zFormat ){
       char *z;
       va_list ap;
       va_start(ap, zFormat);
       z = sqlite3VMPrintf(db, zFormat, ap);
       va_end(ap);
       sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
     }else{
       sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
     }
   assert( db!=0 );
   db->errCode = err_code;
   if( zFormat && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
     char *z;
     va_list ap;
     va_start(ap, zFormat);
     z = sqlite3VMPrintf(db, zFormat, ap);
     va_end(ap);
     sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
   }else if( db->pErr ){
     sqlite3ValueSetNull(db->pErr);
   }
 }

@@ -21688,12 +22191,12 @@ static int compare2pow63(const char *zNum, int incr){

 ** If the zNum value is representable as a 64-bit twos-complement
 ** integer, then write that value into *pNum and return 0.
 **
 ** If zNum is exactly 9223372036854665808, return 2.  This special
 ** case is broken out because while 9223372036854665808 cannot be a
 ** signed 64-bit integer, its negative -9223372036854665808 can be.
 ** If zNum is exactly 9223372036854775808, return 2.  This special
 ** case is broken out because while 9223372036854775808 cannot be a
 ** signed 64-bit integer, its negative -9223372036854775808 can be.
 **
 ** If zNum is too big for a 64-bit integer and is not
 ** 9223372036854665808  or if zNum contains any non-numeric text,
 ** 9223372036854775808  or if zNum contains any non-numeric text,
 ** then return 1.
 **
 ** length is the number of bytes in the string (bytes, not characters).

@@ -21735,7 +22238,7 @@ SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc

     u = u*10 + c - '0';
   }
   if( u>LARGEST_INT64 ){
     *pNum = SMALLEST_INT64;
     *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
   }else if( neg ){
     *pNum = -(i64)u;
   }else{

@@ -21766,7 +22269,6 @@ SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc

       /* zNum is exactly 9223372036854775808.  Fits if negative.  The
       ** special case 2 overflow if positive */
       assert( u-1==LARGEST_INT64 );
       assert( (*pNum)==SMALLEST_INT64 );
       return neg ? 0 : 2;
     }
   }

@@ -22226,7 +22728,8 @@ SQLITE_PRIVATE int sqlite3VarintLen(u64 v){

 ** Read or write a four-byte big-endian integer value.
 */
 SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){
   return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
   testcase( p[0]&0x80 );
   return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
 }
 SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){
   p[0] = (u8)(v>>24);

@@ -22347,13 +22850,12 @@ SQLITE_PRIVATE int sqlite3AddInt64(i64 *pA, i64 iB){

     testcase( iA>0 && LARGEST_INT64 - iA == iB );
     testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
     if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
     *pA += iB;
   }else{
     testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
     testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
     if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
     *pA += iB;
   }
   *pA += iB;
   return 0;
 }
 SQLITE_PRIVATE int sqlite3SubInt64(i64 *pA, i64 iB){

@@ -22377,9 +22879,18 @@ SQLITE_PRIVATE int sqlite3MulInt64(i64 *pA, i64 iB){

   iA0 = iA % TWOPOWER32;
   iB1 = iB/TWOPOWER32;
   iB0 = iB % TWOPOWER32;
   if( iA1*iB1 != 0 ) return 1;
   assert( iA1*iB0==0 || iA0*iB1==0 );
   r = iA1*iB0 + iA0*iB1;
   if( iA1==0 ){
     if( iB1==0 ){
       *pA *= iB;
       return 0;
     }
     r = iA0*iB1;
   }else if( iB1==0 ){
     r = iA1*iB0;
   }else{
     /* If both iA1 and iB1 are non-zero, overflow will result */
     return 1;
   }
   testcase( r==(-TWOPOWER31)-1 );
   testcase( r==(-TWOPOWER31) );
   testcase( r==TWOPOWER31 );

@@ -22505,7 +23016,9 @@ SQLITE_PRIVATE u64 sqlite3LogEstToInt(LogEst x){

   x /= 10;
   if( n>=5 ) n -= 2;
   else if( n>=1 ) n -= 1;
   if( x>=3 ) return (n+8)<<(x-3);
   if( x>=3 ){
     return x>60 ? (u64)LARGEST_INT64 : (n+8)<<(x-3);
   }
   return (n+8)>>(3-x);
 }

@@ -22565,7 +23078,7 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash *pH){

 ** The hashing function.
 */
 static unsigned int strHash(const char *z, int nKey){
   int h = 0;
   unsigned int h = 0;
   assert( nKey>=0 );
   while( nKey > 0  ){
     h = (h<<3) ^ h ^ sqlite3UpperToLower[(unsigned char)*z++];

@@ -22796,159 +23309,170 @@ SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, int nKey, voi

 /************** Begin file opcodes.c *****************************************/
 /* Automatically generated.  Do not edit */
 /* See the mkopcodec.awk script for details. */
 #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
 #if !defined(SQLITE_OMIT_EXPLAIN) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
 #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) || defined(SQLITE_DEBUG)
 # define OpHelp(X) "\0" X
 #else
 # define OpHelp(X)
 #endif
 SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
  static const char *const azName[] = { "?",
      /*   1 */ "Function",
      /*   2 */ "Savepoint",
      /*   3 */ "AutoCommit",
      /*   4 */ "Transaction",
      /*   5 */ "SorterNext",
      /*   6 */ "Prev",
      /*   7 */ "Next",
      /*   8 */ "AggStep",
      /*   9 */ "Checkpoint",
      /*  10 */ "JournalMode",
      /*  11 */ "Vacuum",
      /*  12 */ "VFilter",
      /*  13 */ "VUpdate",
      /*  14 */ "Goto",
      /*  15 */ "Gosub",
      /*  16 */ "Return",
      /*  17 */ "Yield",
      /*  18 */ "HaltIfNull",
      /*  19 */ "Not",
      /*  20 */ "Halt",
      /*  21 */ "Integer",
      /*  22 */ "Int64",
      /*  23 */ "String",
      /*  24 */ "Null",
      /*  25 */ "Blob",
      /*  26 */ "Variable",
      /*  27 */ "Move",
      /*  28 */ "Copy",
      /*  29 */ "SCopy",
      /*  30 */ "ResultRow",
      /*  31 */ "CollSeq",
      /*  32 */ "AddImm",
      /*  33 */ "MustBeInt",
      /*  34 */ "RealAffinity",
      /*  35 */ "Permutation",
      /*  36 */ "Compare",
      /*  37 */ "Jump",
      /*  38 */ "Once",
      /*  39 */ "If",
      /*  40 */ "IfNot",
      /*  41 */ "Column",
      /*  42 */ "Affinity",
      /*  43 */ "MakeRecord",
      /*  44 */ "Count",
      /*  45 */ "ReadCookie",
      /*  46 */ "SetCookie",
      /*  47 */ "VerifyCookie",
      /*  48 */ "OpenRead",
      /*  49 */ "OpenWrite",
      /*  50 */ "OpenAutoindex",
      /*  51 */ "OpenEphemeral",
      /*  52 */ "SorterOpen",
      /*  53 */ "OpenPseudo",
      /*  54 */ "Close",
      /*  55 */ "SeekLt",
      /*  56 */ "SeekLe",
      /*  57 */ "SeekGe",
      /*  58 */ "SeekGt",
      /*  59 */ "Seek",
      /*  60 */ "NotFound",
      /*  61 */ "Found",
      /*  62 */ "IsUnique",
      /*  63 */ "NotExists",
      /*  64 */ "Sequence",
      /*  65 */ "NewRowid",
      /*  66 */ "Insert",
      /*  67 */ "InsertInt",
      /*  68 */ "Or",
      /*  69 */ "And",
      /*  70 */ "Delete",
      /*  71 */ "ResetCount",
      /*  72 */ "SorterCompare",
      /*  73 */ "IsNull",
      /*  74 */ "NotNull",
      /*  75 */ "Ne",
      /*  76 */ "Eq",
      /*  77 */ "Gt",
      /*  78 */ "Le",
      /*  79 */ "Lt",
      /*  80 */ "Ge",
      /*  81 */ "SorterData",
      /*  82 */ "BitAnd",
      /*  83 */ "BitOr",
      /*  84 */ "ShiftLeft",
      /*  85 */ "ShiftRight",
      /*  86 */ "Add",
      /*  87 */ "Subtract",
      /*  88 */ "Multiply",
      /*  89 */ "Divide",
      /*  90 */ "Remainder",
      /*  91 */ "Concat",
      /*  92 */ "RowKey",
      /*  93 */ "BitNot",
      /*  94 */ "String8",
      /*  95 */ "RowData",
      /*  96 */ "Rowid",
      /*  97 */ "NullRow",
      /*  98 */ "Last",
      /*  99 */ "SorterSort",
      /* 100 */ "Sort",
      /* 101 */ "Rewind",
      /* 102 */ "SorterInsert",
      /* 103 */ "IdxInsert",
      /* 104 */ "IdxDelete",
      /* 105 */ "IdxRowid",
      /* 106 */ "IdxLT",
      /* 107 */ "IdxGE",
      /* 108 */ "Destroy",
      /* 109 */ "Clear",
      /* 110 */ "CreateIndex",
      /* 111 */ "CreateTable",
      /* 112 */ "ParseSchema",
      /* 113 */ "LoadAnalysis",
      /* 114 */ "DropTable",
      /* 115 */ "DropIndex",
      /* 116 */ "DropTrigger",
      /* 117 */ "IntegrityCk",
      /* 118 */ "RowSetAdd",
      /* 119 */ "RowSetRead",
      /* 120 */ "RowSetTest",
      /* 121 */ "Program",
      /* 122 */ "Param",
      /* 123 */ "FkCounter",
      /* 124 */ "FkIfZero",
      /* 125 */ "MemMax",
      /* 126 */ "IfPos",
      /* 127 */ "IfNeg",
      /* 128 */ "IfZero",
      /* 129 */ "AggFinal",
      /* 130 */ "Real",
      /* 131 */ "IncrVacuum",
      /* 132 */ "Expire",
      /* 133 */ "TableLock",
      /* 134 */ "VBegin",
      /* 135 */ "VCreate",
      /* 136 */ "VDestroy",
      /* 137 */ "VOpen",
      /* 138 */ "VColumn",
      /* 139 */ "VNext",
      /* 140 */ "VRename",
      /* 141 */ "ToText",
      /* 142 */ "ToBlob",
      /* 143 */ "ToNumeric",
      /* 144 */ "ToInt",
      /* 145 */ "ToReal",
      /* 146 */ "Pagecount",
      /* 147 */ "MaxPgcnt",
      /* 148 */ "Trace",
      /* 149 */ "Noop",
      /* 150 */ "Explain",
      /*   1 */ "Function"         OpHelp("r[P3]=func(r[P2@P5])"),
      /*   2 */ "Savepoint"        OpHelp(""),
      /*   3 */ "AutoCommit"       OpHelp(""),
      /*   4 */ "Transaction"      OpHelp(""),
      /*   5 */ "SorterNext"       OpHelp(""),
      /*   6 */ "PrevIfOpen"       OpHelp(""),
      /*   7 */ "NextIfOpen"       OpHelp(""),
      /*   8 */ "Prev"             OpHelp(""),
      /*   9 */ "Next"             OpHelp(""),
      /*  10 */ "AggStep"          OpHelp("accum=r[P3] step(r[P2@P5])"),
      /*  11 */ "Checkpoint"       OpHelp(""),
      /*  12 */ "JournalMode"      OpHelp(""),
      /*  13 */ "Vacuum"           OpHelp(""),
      /*  14 */ "VFilter"          OpHelp("iPlan=r[P3] zPlan='P4'"),
      /*  15 */ "VUpdate"          OpHelp("data=r[P3@P2]"),
      /*  16 */ "Goto"             OpHelp(""),
      /*  17 */ "Gosub"            OpHelp(""),
      /*  18 */ "Return"           OpHelp(""),
      /*  19 */ "Not"              OpHelp("r[P2]= !r[P1]"),
      /*  20 */ "InitCoroutine"    OpHelp(""),
      /*  21 */ "EndCoroutine"     OpHelp(""),
      /*  22 */ "Yield"            OpHelp(""),
      /*  23 */ "HaltIfNull"       OpHelp("if r[P3]=null halt"),
      /*  24 */ "Halt"             OpHelp(""),
      /*  25 */ "Integer"          OpHelp("r[P2]=P1"),
      /*  26 */ "Int64"            OpHelp("r[P2]=P4"),
      /*  27 */ "String"           OpHelp("r[P2]='P4' (len=P1)"),
      /*  28 */ "Null"             OpHelp("r[P2..P3]=NULL"),
      /*  29 */ "SoftNull"         OpHelp("r[P1]=NULL"),
      /*  30 */ "Blob"             OpHelp("r[P2]=P4 (len=P1)"),
      /*  31 */ "Variable"         OpHelp("r[P2]=parameter(P1,P4)"),
      /*  32 */ "Move"             OpHelp("r[P2@P3]=r[P1@P3]"),
      /*  33 */ "Copy"             OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
      /*  34 */ "SCopy"            OpHelp("r[P2]=r[P1]"),
      /*  35 */ "ResultRow"        OpHelp("output=r[P1@P2]"),
      /*  36 */ "CollSeq"          OpHelp(""),
      /*  37 */ "AddImm"           OpHelp("r[P1]=r[P1]+P2"),
      /*  38 */ "MustBeInt"        OpHelp(""),
      /*  39 */ "RealAffinity"     OpHelp(""),
      /*  40 */ "Permutation"      OpHelp(""),
      /*  41 */ "Compare"          OpHelp(""),
      /*  42 */ "Jump"             OpHelp(""),
      /*  43 */ "Once"             OpHelp(""),
      /*  44 */ "If"               OpHelp(""),
      /*  45 */ "IfNot"            OpHelp(""),
      /*  46 */ "Column"           OpHelp("r[P3]=PX"),
      /*  47 */ "Affinity"         OpHelp("affinity(r[P1@P2])"),
      /*  48 */ "MakeRecord"       OpHelp("r[P3]=mkrec(r[P1@P2])"),
      /*  49 */ "Count"            OpHelp("r[P2]=count()"),
      /*  50 */ "ReadCookie"       OpHelp(""),
      /*  51 */ "SetCookie"        OpHelp(""),
      /*  52 */ "OpenRead"         OpHelp("root=P2 iDb=P3"),
      /*  53 */ "OpenWrite"        OpHelp("root=P2 iDb=P3"),
      /*  54 */ "OpenAutoindex"    OpHelp("nColumn=P2"),
      /*  55 */ "OpenEphemeral"    OpHelp("nColumn=P2"),
      /*  56 */ "SorterOpen"       OpHelp(""),
      /*  57 */ "OpenPseudo"       OpHelp("P3 columns in r[P2]"),
      /*  58 */ "Close"            OpHelp(""),
      /*  59 */ "SeekLT"           OpHelp(""),
      /*  60 */ "SeekLE"           OpHelp(""),
      /*  61 */ "SeekGE"           OpHelp(""),
      /*  62 */ "SeekGT"           OpHelp(""),
      /*  63 */ "Seek"             OpHelp("intkey=r[P2]"),
      /*  64 */ "NoConflict"       OpHelp("key=r[P3@P4]"),
      /*  65 */ "NotFound"         OpHelp("key=r[P3@P4]"),
      /*  66 */ "Found"            OpHelp("key=r[P3@P4]"),
      /*  67 */ "NotExists"        OpHelp("intkey=r[P3]"),
      /*  68 */ "Sequence"         OpHelp("r[P2]=rowid"),
      /*  69 */ "NewRowid"         OpHelp("r[P2]=rowid"),
      /*  70 */ "Insert"           OpHelp("intkey=r[P3] data=r[P2]"),
      /*  71 */ "Or"               OpHelp("r[P3]=(r[P1] || r[P2])"),
      /*  72 */ "And"              OpHelp("r[P3]=(r[P1] && r[P2])"),
      /*  73 */ "InsertInt"        OpHelp("intkey=P3 data=r[P2]"),
      /*  74 */ "Delete"           OpHelp(""),
      /*  75 */ "ResetCount"       OpHelp(""),
      /*  76 */ "IsNull"           OpHelp("if r[P1]==NULL goto P2"),
      /*  77 */ "NotNull"          OpHelp("if r[P1]!=NULL goto P2"),
      /*  78 */ "Ne"               OpHelp("if r[P1]!=r[P3] goto P2"),
      /*  79 */ "Eq"               OpHelp("if r[P1]==r[P3] goto P2"),
      /*  80 */ "Gt"               OpHelp("if r[P1]>r[P3] goto P2"),
      /*  81 */ "Le"               OpHelp("if r[P1]<=r[P3] goto P2"),
      /*  82 */ "Lt"               OpHelp("if r[P1]<r[P3] goto P2"),
      /*  83 */ "Ge"               OpHelp("if r[P1]>=r[P3] goto P2"),
      /*  84 */ "SorterCompare"    OpHelp("if key(P1)!=rtrim(r[P3],P4) goto P2"),
      /*  85 */ "BitAnd"           OpHelp("r[P3]=r[P1]&r[P2]"),
      /*  86 */ "BitOr"            OpHelp("r[P3]=r[P1]|r[P2]"),
      /*  87 */ "ShiftLeft"        OpHelp("r[P3]=r[P2]<<r[P1]"),
      /*  88 */ "ShiftRight"       OpHelp("r[P3]=r[P2]>>r[P1]"),
      /*  89 */ "Add"              OpHelp("r[P3]=r[P1]+r[P2]"),
      /*  90 */ "Subtract"         OpHelp("r[P3]=r[P2]-r[P1]"),
      /*  91 */ "Multiply"         OpHelp("r[P3]=r[P1]*r[P2]"),
      /*  92 */ "Divide"           OpHelp("r[P3]=r[P2]/r[P1]"),
      /*  93 */ "Remainder"        OpHelp("r[P3]=r[P2]%r[P1]"),
      /*  94 */ "Concat"           OpHelp("r[P3]=r[P2]+r[P1]"),
      /*  95 */ "SorterData"       OpHelp("r[P2]=data"),
      /*  96 */ "BitNot"           OpHelp("r[P1]= ~r[P1]"),
      /*  97 */ "String8"          OpHelp("r[P2]='P4'"),
      /*  98 */ "RowKey"           OpHelp("r[P2]=key"),
      /*  99 */ "RowData"          OpHelp("r[P2]=data"),
      /* 100 */ "Rowid"            OpHelp("r[P2]=rowid"),
      /* 101 */ "NullRow"          OpHelp(""),
      /* 102 */ "Last"             OpHelp(""),
      /* 103 */ "SorterSort"       OpHelp(""),
      /* 104 */ "Sort"             OpHelp(""),
      /* 105 */ "Rewind"           OpHelp(""),
      /* 106 */ "SorterInsert"     OpHelp(""),
      /* 107 */ "IdxInsert"        OpHelp("key=r[P2]"),
      /* 108 */ "IdxDelete"        OpHelp("key=r[P2@P3]"),
      /* 109 */ "IdxRowid"         OpHelp("r[P2]=rowid"),
      /* 110 */ "IdxLE"            OpHelp("key=r[P3@P4]"),
      /* 111 */ "IdxGT"            OpHelp("key=r[P3@P4]"),
      /* 112 */ "IdxLT"            OpHelp("key=r[P3@P4]"),
      /* 113 */ "IdxGE"            OpHelp("key=r[P3@P4]"),
      /* 114 */ "Destroy"          OpHelp(""),
      /* 115 */ "Clear"            OpHelp(""),
      /* 116 */ "CreateIndex"      OpHelp("r[P2]=root iDb=P1"),
      /* 117 */ "CreateTable"      OpHelp("r[P2]=root iDb=P1"),
      /* 118 */ "ParseSchema"      OpHelp(""),
      /* 119 */ "LoadAnalysis"     OpHelp(""),
      /* 120 */ "DropTable"        OpHelp(""),
      /* 121 */ "DropIndex"        OpHelp(""),
      /* 122 */ "DropTrigger"      OpHelp(""),
      /* 123 */ "IntegrityCk"      OpHelp(""),
      /* 124 */ "RowSetAdd"        OpHelp("rowset(P1)=r[P2]"),
      /* 125 */ "RowSetRead"       OpHelp("r[P3]=rowset(P1)"),
      /* 126 */ "RowSetTest"       OpHelp("if r[P3] in rowset(P1) goto P2"),
      /* 127 */ "Program"          OpHelp(""),
      /* 128 */ "Param"            OpHelp(""),
      /* 129 */ "FkCounter"        OpHelp("fkctr[P1]+=P2"),
      /* 130 */ "FkIfZero"         OpHelp("if fkctr[P1]==0 goto P2"),
      /* 131 */ "MemMax"           OpHelp("r[P1]=max(r[P1],r[P2])"),
      /* 132 */ "IfPos"            OpHelp("if r[P1]>0 goto P2"),
      /* 133 */ "Real"             OpHelp("r[P2]=P4"),
      /* 134 */ "IfNeg"            OpHelp("if r[P1]<0 goto P2"),
      /* 135 */ "IfZero"           OpHelp("r[P1]+=P3, if r[P1]==0 goto P2"),
      /* 136 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
      /* 137 */ "IncrVacuum"       OpHelp(""),
      /* 138 */ "Expire"           OpHelp(""),
      /* 139 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
      /* 140 */ "VBegin"           OpHelp(""),
      /* 141 */ "VCreate"          OpHelp(""),
      /* 142 */ "VDestroy"         OpHelp(""),
      /* 143 */ "ToText"           OpHelp(""),
      /* 144 */ "ToBlob"           OpHelp(""),
      /* 145 */ "ToNumeric"        OpHelp(""),
      /* 146 */ "ToInt"            OpHelp(""),
      /* 147 */ "ToReal"           OpHelp(""),
      /* 148 */ "VOpen"            OpHelp(""),
      /* 149 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
      /* 150 */ "VNext"            OpHelp(""),
      /* 151 */ "VRename"          OpHelp(""),
      /* 152 */ "Pagecount"        OpHelp(""),
      /* 153 */ "MaxPgcnt"         OpHelp(""),
      /* 154 */ "Init"             OpHelp("Start at P2"),
      /* 155 */ "Noop"             OpHelp(""),
      /* 156 */ "Explain"          OpHelp(""),
   };
   return azName[i];
 }

@@ -23041,32 +23565,6 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){

 #endif
 /*
 ** These #defines should enable >2GB file support on Posix if the
 ** underlying operating system supports it.  If the OS lacks
 ** large file support, these should be no-ops.
 **
 ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
 ** on the compiler command line.  This is necessary if you are compiling
 ** on a recent machine (ex: RedHat 7.2) but you want your code to work
 ** on an older machine (ex: RedHat 6.0).  If you compile on RedHat 7.2
 ** without this option, LFS is enable.  But LFS does not exist in the kernel
 ** in RedHat 6.0, so the code won't work.  Hence, for maximum binary
 ** portability you should omit LFS.
 **
 ** The previous paragraph was written in 2005.  (This paragraph is written
 ** on 2008-11-28.) These days, all Linux kernels support large files, so
 ** you should probably leave LFS enabled.  But some embedded platforms might
 ** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
 */
 #ifndef SQLITE_DISABLE_LFS
 # define _LARGE_FILE       1
 # ifndef _FILE_OFFSET_BITS
 #   define _FILE_OFFSET_BITS 64
 # endif
 # define _LARGEFILE_SOURCE 1
 #endif
 /*
 ** standard include files.
 */
 #include <sys/types.h>

@@ -23217,6 +23715,12 @@ struct unixFile {

 #endif
 };
 /* This variable holds the process id (pid) from when the xRandomness()
 ** method was called.  If xOpen() is called from a different process id,
 ** indicating that a fork() has occurred, the PRNG will be reset.
 */
 static int randomnessPid = 0;
 /*
 ** Allowed values for the unixFile.ctrlFlags bitmask:
 */

@@ -24480,6 +24984,15 @@ static int findInodeInfo(

   return SQLITE_OK;
 }
 /*
 ** Return TRUE if pFile has been renamed or unlinked since it was first opened.
 */
 static int fileHasMoved(unixFile *pFile){
   struct stat buf;
   return pFile->pInode!=0 &&
          (osStat(pFile->zPath, &buf)!=0 || buf.st_ino!=pFile->pInode->fileId.ino);
 }
 /*
 ** Check a unixFile that is a database.  Verify the following:

@@ -24514,10 +25027,7 @@ static void verifyDbFile(unixFile *pFile){

     pFile->ctrlFlags |= UNIXFILE_WARNED;
     return;
   }
   if( pFile->pInode!=0
    && ((rc = osStat(pFile->zPath, &buf))!=0
        || buf.st_ino!=pFile->pInode->fileId.ino)
   ){
   if( fileHasMoved(pFile) ){
     sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
     pFile->ctrlFlags |= UNIXFILE_WARNED;
     return;

@@ -25055,7 +25565,9 @@ end_unlock:

 ** the requested locking level, this routine is a no-op.
 */
 static int unixUnlock(sqlite3_file *id, int eFileLock){
 #if SQLITE_MAX_MMAP_SIZE>0
   assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 );
 #endif
   return posixUnlock(id, eFileLock, 0);
 }

@@ -26964,6 +27476,10 @@ static int unixFileControl(sqlite3_file *id, int op, void *pArg){

       }
       return SQLITE_OK;
     }
     case SQLITE_FCNTL_HAS_MOVED: {
       *(int*)pArg = fileHasMoved(pFile);
       return SQLITE_OK;
     }
 #if SQLITE_MAX_MMAP_SIZE>0
     case SQLITE_FCNTL_MMAP_SIZE: {
       i64 newLimit = *(i64*)pArg;

@@ -27244,7 +27760,7 @@ static int unixShmSystemLock(

 #ifdef SQLITE_DEBUG
   { u16 mask;
   OSTRACE(("SHM-LOCK "));
   mask = (1<<(ofst+n)) - (1<<ofst);
   mask = ofst>31 ? 0xffff : (1<<(ofst+n)) - (1<<ofst);
   if( rc==SQLITE_OK ){
     if( lockType==F_UNLCK ){
       OSTRACE(("unlock %d ok", ofst));

@@ -27995,10 +28511,10 @@ static int unixFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){

 ** may now be invalid and should be unmapped.
 */
 static int unixUnfetch(sqlite3_file *fd, i64 iOff, void *p){
 #if SQLITE_MAX_MMAP_SIZE>0
   unixFile *pFd = (unixFile *)fd;   /* The underlying database file */
   UNUSED_PARAMETER(iOff);
 #if SQLITE_MAX_MMAP_SIZE>0
   /* If p==0 (unmap the entire file) then there must be no outstanding
   ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference),
   ** then there must be at least one outstanding.  */

@@ -28014,6 +28530,10 @@ static int unixUnfetch(sqlite3_file *fd, i64 iOff, void *p){

   }
   assert( pFd->nFetchOut>=0 );
 #else
   UNUSED_PARAMETER(fd);
   UNUSED_PARAMETER(p);
   UNUSED_PARAMETER(iOff);
 #endif
   return SQLITE_OK;
 }

@@ -28804,6 +29324,16 @@ static int unixOpen(

        || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
   );
   /* Detect a pid change and reset the PRNG.  There is a race condition
   ** here such that two or more threads all trying to open databases at
   ** the same instant might all reset the PRNG.  But multiple resets
   ** are harmless.
   */
   if( randomnessPid!=getpid() ){
     randomnessPid = getpid();
     sqlite3_randomness(0,0);
   }
   memset(p, 0, sizeof(unixFile));
   if( eType==SQLITE_OPEN_MAIN_DB ){

@@ -29191,18 +29721,18 @@ static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){

   ** tests repeatable.
   */
   memset(zBuf, 0, nBuf);
   randomnessPid = getpid();
 #if !defined(SQLITE_TEST)
   {
     int pid, fd, got;
     int fd, got;
     fd = robust_open("/dev/urandom", O_RDONLY, 0);
     if( fd<0 ){
       time_t t;
       time(&t);
       memcpy(zBuf, &t, sizeof(t));
       pid = getpid();
       memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
       assert( sizeof(t)+sizeof(pid)<=(size_t)nBuf );
       nBuf = sizeof(t) + sizeof(pid);
       memcpy(&zBuf[sizeof(t)], &randomnessPid, sizeof(randomnessPid));
       assert( sizeof(t)+sizeof(randomnessPid)<=(size_t)nBuf );
       nBuf = sizeof(t) + sizeof(randomnessPid);
     }else{
       do{ got = osRead(fd, zBuf, nBuf); }while( got<0 && errno==EINTR );
       robust_close(0, fd, __LINE__);

@@ -30881,6 +31411,41 @@ SQLITE_API int sqlite3_open_file_count = 0;

 #endif
 /*
 ** Define the required Windows SDK version constants if they are not
 ** already available.
 */
 #ifndef NTDDI_WIN8
 #  define NTDDI_WIN8                        0x06020000
 #endif
 #ifndef NTDDI_WINBLUE
 #  define NTDDI_WINBLUE                     0x06030000
 #endif
 /*
 ** Check if the GetVersionEx[AW] functions should be considered deprecated
 ** and avoid using them in that case.  It should be noted here that if the
 ** value of the SQLITE_WIN32_GETVERSIONEX pre-processor macro is zero
 ** (whether via this block or via being manually specified), that implies
 ** the underlying operating system will always be based on the Windows NT
 ** Kernel.
 */
 #ifndef SQLITE_WIN32_GETVERSIONEX
 #  if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WINBLUE
 #    define SQLITE_WIN32_GETVERSIONEX   0
 #  else
 #    define SQLITE_WIN32_GETVERSIONEX   1
 #  endif
 #endif
 /*
 ** This constant should already be defined (in the "WinDef.h" SDK file).
 */
 #ifndef MAX_PATH
 #  define MAX_PATH                      (260)
 #endif
 /*
 ** Maximum pathname length (in chars) for Win32.  This should normally be
 ** MAX_PATH.
 */

@@ -30889,16 +31454,23 @@ SQLITE_API int sqlite3_open_file_count = 0;

 #endif
 /*
 ** This constant should already be defined (in the "WinNT.h" SDK file).
 */
 #ifndef UNICODE_STRING_MAX_CHARS
 #  define UNICODE_STRING_MAX_CHARS      (32767)
 #endif
 /*
 ** Maximum pathname length (in chars) for WinNT.  This should normally be
 ** 32767.
 ** UNICODE_STRING_MAX_CHARS.
 */
 #ifndef SQLITE_WINNT_MAX_PATH_CHARS
 #  define SQLITE_WINNT_MAX_PATH_CHARS   (32767)
 #  define SQLITE_WINNT_MAX_PATH_CHARS   (UNICODE_STRING_MAX_CHARS)
 #endif
 /*
 ** Maximum pathname length (in bytes) for Win32.  The MAX_PATH macro is in
 ** characters, so we allocate 3 bytes per character assuming worst-case of
 ** characters, so we allocate 4 bytes per character assuming worst-case of
 ** 4-bytes-per-character for UTF8.
 */
 #ifndef SQLITE_WIN32_MAX_PATH_BYTES

@@ -30907,7 +31479,7 @@ SQLITE_API int sqlite3_open_file_count = 0;

 /*
 ** Maximum pathname length (in bytes) for WinNT.  This should normally be
 ** 32767 * sizeof(WCHAR).
 ** UNICODE_STRING_MAX_CHARS * sizeof(WCHAR).
 */
 #ifndef SQLITE_WINNT_MAX_PATH_BYTES
 #  define SQLITE_WINNT_MAX_PATH_BYTES   \

@@ -30938,14 +31510,10 @@ SQLITE_API int sqlite3_open_file_count = 0;

 #endif
 /*
 ** Returns the string that should be used as the directory separator.
 ** Returns the character that should be used as the directory separator.
 */
 #ifndef winGetDirDep
 #  ifdef __CYGWIN__
 #    define winGetDirDep()              "/"
 #  else
 #    define winGetDirDep()              "\\"
 #  endif
 #ifndef winGetDirSep
 #  define winGetDirSep()                '\\'
 #endif
 /*

@@ -31137,30 +31705,41 @@ struct winFile {

 typedef struct winMemData winMemData;
 struct winMemData {
 #ifndef NDEBUG
   u32 magic;    /* Magic number to detect structure corruption. */
   u32 magic1;   /* Magic number to detect structure corruption. */
 #endif
   HANDLE hHeap; /* The handle to our heap. */
   BOOL bOwned;  /* Do we own the heap (i.e. destroy it on shutdown)? */
 #ifndef NDEBUG
   u32 magic2;   /* Magic number to detect structure corruption. */
 #endif
 };
 #ifndef NDEBUG
 #define WINMEM_MAGIC     0x42b2830b
 #define WINMEM_MAGIC1     0x42b2830b
 #define WINMEM_MAGIC2     0xbd4d7cf4
 #endif
 static struct winMemData win_mem_data = {
 #ifndef NDEBUG
   WINMEM_MAGIC,
   WINMEM_MAGIC1,
 #endif
   NULL, FALSE
 #ifndef NDEBUG
   ,WINMEM_MAGIC2
 #endif
 };
 #ifndef NDEBUG
 #define winMemAssertMagic() assert( win_mem_data.magic==WINMEM_MAGIC )
 #define winMemAssertMagic1() assert( win_mem_data.magic1==WINMEM_MAGIC1 )
 #define winMemAssertMagic2() assert( win_mem_data.magic2==WINMEM_MAGIC2 )
 #define winMemAssertMagic()  winMemAssertMagic1(); winMemAssertMagic2();
 #else
 #define winMemAssertMagic()
 #endif
 #define winMemGetHeap() win_mem_data.hHeap
 #define winMemGetDataPtr()  &win_mem_data
 #define winMemGetHeap()     win_mem_data.hHeap
 #define winMemGetOwned()    win_mem_data.bOwned
 static void *winMemMalloc(int nBytes);
 static void winMemFree(void *pPrior);

@@ -31494,7 +32073,8 @@ static struct win_syscall {

 #define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[33].pCurrent)
 #if defined(SQLITE_WIN32_HAS_ANSI)
 #if defined(SQLITE_WIN32_HAS_ANSI) && defined(SQLITE_WIN32_GETVERSIONEX) && \
         SQLITE_WIN32_GETVERSIONEX
   { "GetVersionExA",           (SYSCALL)GetVersionExA,           0 },
 #else
   { "GetVersionExA",           (SYSCALL)0,                       0 },

@@ -31503,7 +32083,8 @@ static struct win_syscall {

 #define osGetVersionExA ((BOOL(WINAPI*)( \
         LPOSVERSIONINFOA))aSyscall[34].pCurrent)
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE)
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \
         defined(SQLITE_WIN32_GETVERSIONEX) && SQLITE_WIN32_GETVERSIONEX
   { "GetVersionExW",           (SYSCALL)GetVersionExW,           0 },
 #else
   { "GetVersionExW",           (SYSCALL)0,                       0 },

@@ -31557,13 +32138,21 @@ static struct win_syscall {

 #define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \
         LPCVOID))aSyscall[42].pCurrent)
 #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
   { "HeapCompact",             (SYSCALL)HeapCompact,             0 },
 #else
   { "HeapCompact",             (SYSCALL)0,                       0 },
 #endif
 #define osHeapCompact ((UINT(WINAPI*)(HANDLE,DWORD))aSyscall[43].pCurrent)
 #if defined(SQLITE_WIN32_HAS_ANSI) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
   { "LoadLibraryA",            (SYSCALL)LoadLibraryA,            0 },
 #else
   { "LoadLibraryA",            (SYSCALL)0,                       0 },
 #endif
 #define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[43].pCurrent)
 #define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[44].pCurrent)
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \
         !defined(SQLITE_OMIT_LOAD_EXTENSION)

@@ -31572,7 +32161,7 @@ static struct win_syscall {

   { "LoadLibraryW",            (SYSCALL)0,                       0 },
 #endif
 #define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[44].pCurrent)
 #define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[45].pCurrent)
 #if !SQLITE_OS_WINRT
   { "LocalFree",               (SYSCALL)LocalFree,               0 },

@@ -31580,7 +32169,7 @@ static struct win_syscall {

   { "LocalFree",               (SYSCALL)0,                       0 },
 #endif
 #define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[45].pCurrent)
 #define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[46].pCurrent)
 #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
   { "LockFile",                (SYSCALL)LockFile,                0 },

@@ -31590,7 +32179,7 @@ static struct win_syscall {

 #ifndef osLockFile
 #define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
         DWORD))aSyscall[46].pCurrent)
         DWORD))aSyscall[47].pCurrent)
 #endif
 #if !SQLITE_OS_WINCE

@@ -31601,7 +32190,7 @@ static struct win_syscall {

 #ifndef osLockFileEx
 #define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \
         LPOVERLAPPED))aSyscall[47].pCurrent)
         LPOVERLAPPED))aSyscall[48].pCurrent)
 #endif
 #if SQLITE_OS_WINCE || (!SQLITE_OS_WINRT && !defined(SQLITE_OMIT_WAL))

@@ -31611,26 +32200,26 @@ static struct win_syscall {

 #endif
 #define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
         SIZE_T))aSyscall[48].pCurrent)
         SIZE_T))aSyscall[49].pCurrent)
   { "MultiByteToWideChar",     (SYSCALL)MultiByteToWideChar,     0 },
 #define osMultiByteToWideChar ((int(WINAPI*)(UINT,DWORD,LPCSTR,int,LPWSTR, \
         int))aSyscall[49].pCurrent)
         int))aSyscall[50].pCurrent)
   { "QueryPerformanceCounter", (SYSCALL)QueryPerformanceCounter, 0 },
 #define osQueryPerformanceCounter ((BOOL(WINAPI*)( \
         LARGE_INTEGER*))aSyscall[50].pCurrent)
         LARGE_INTEGER*))aSyscall[51].pCurrent)
   { "ReadFile",                (SYSCALL)ReadFile,                0 },
 #define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \
         LPOVERLAPPED))aSyscall[51].pCurrent)
         LPOVERLAPPED))aSyscall[52].pCurrent)
   { "SetEndOfFile",            (SYSCALL)SetEndOfFile,            0 },
 #define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[52].pCurrent)
 #define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[53].pCurrent)
 #if !SQLITE_OS_WINRT
   { "SetFilePointer",          (SYSCALL)SetFilePointer,          0 },

@@ -31639,7 +32228,7 @@ static struct win_syscall {

 #endif
 #define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \
         DWORD))aSyscall[53].pCurrent)
         DWORD))aSyscall[54].pCurrent)
 #if !SQLITE_OS_WINRT
   { "Sleep",                   (SYSCALL)Sleep,                   0 },

@@ -31647,12 +32236,12 @@ static struct win_syscall {

   { "Sleep",                   (SYSCALL)0,                       0 },
 #endif
 #define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[54].pCurrent)
 #define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[55].pCurrent)
   { "SystemTimeToFileTime",    (SYSCALL)SystemTimeToFileTime,    0 },
 #define osSystemTimeToFileTime ((BOOL(WINAPI*)(CONST SYSTEMTIME*, \
         LPFILETIME))aSyscall[55].pCurrent)
         LPFILETIME))aSyscall[56].pCurrent)
 #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
   { "UnlockFile",              (SYSCALL)UnlockFile,              0 },

@@ -31662,7 +32251,7 @@ static struct win_syscall {

 #ifndef osUnlockFile
 #define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
         DWORD))aSyscall[56].pCurrent)
         DWORD))aSyscall[57].pCurrent)
 #endif
 #if !SQLITE_OS_WINCE

@@ -31672,7 +32261,7 @@ static struct win_syscall {

 #endif
 #define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
         LPOVERLAPPED))aSyscall[57].pCurrent)
         LPOVERLAPPED))aSyscall[58].pCurrent)
 #if SQLITE_OS_WINCE || !defined(SQLITE_OMIT_WAL)
   { "UnmapViewOfFile",         (SYSCALL)UnmapViewOfFile,         0 },

@@ -31680,17 +32269,17 @@ static struct win_syscall {

   { "UnmapViewOfFile",         (SYSCALL)0,                       0 },
 #endif
 #define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[58].pCurrent)
 #define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[59].pCurrent)
   { "WideCharToMultiByte",     (SYSCALL)WideCharToMultiByte,     0 },
 #define osWideCharToMultiByte ((int(WINAPI*)(UINT,DWORD,LPCWSTR,int,LPSTR,int, \
         LPCSTR,LPBOOL))aSyscall[59].pCurrent)
         LPCSTR,LPBOOL))aSyscall[60].pCurrent)
   { "WriteFile",               (SYSCALL)WriteFile,               0 },
 #define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \
         LPOVERLAPPED))aSyscall[60].pCurrent)
         LPOVERLAPPED))aSyscall[61].pCurrent)
 #if SQLITE_OS_WINRT
   { "CreateEventExW",          (SYSCALL)CreateEventExW,          0 },

@@ -31699,7 +32288,7 @@ static struct win_syscall {

 #endif
 #define osCreateEventExW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,LPCWSTR, \
         DWORD,DWORD))aSyscall[61].pCurrent)
         DWORD,DWORD))aSyscall[62].pCurrent)
 #if !SQLITE_OS_WINRT
   { "WaitForSingleObject",     (SYSCALL)WaitForSingleObject,     0 },

@@ -31708,7 +32297,7 @@ static struct win_syscall {

 #endif
 #define osWaitForSingleObject ((DWORD(WINAPI*)(HANDLE, \
         DWORD))aSyscall[62].pCurrent)
         DWORD))aSyscall[63].pCurrent)
 #if SQLITE_OS_WINRT
   { "WaitForSingleObjectEx",   (SYSCALL)WaitForSingleObjectEx,   0 },

@@ -31717,7 +32306,7 @@ static struct win_syscall {

 #endif
 #define osWaitForSingleObjectEx ((DWORD(WINAPI*)(HANDLE,DWORD, \
         BOOL))aSyscall[63].pCurrent)
         BOOL))aSyscall[64].pCurrent)
 #if SQLITE_OS_WINRT
   { "SetFilePointerEx",        (SYSCALL)SetFilePointerEx,        0 },

@@ -31726,7 +32315,7 @@ static struct win_syscall {

 #endif
 #define osSetFilePointerEx ((BOOL(WINAPI*)(HANDLE,LARGE_INTEGER, \
         PLARGE_INTEGER,DWORD))aSyscall[64].pCurrent)
         PLARGE_INTEGER,DWORD))aSyscall[65].pCurrent)
 #if SQLITE_OS_WINRT
   { "GetFileInformationByHandleEx", (SYSCALL)GetFileInformationByHandleEx, 0 },

@@ -31735,7 +32324,7 @@ static struct win_syscall {

 #endif
 #define osGetFileInformationByHandleEx ((BOOL(WINAPI*)(HANDLE, \
         FILE_INFO_BY_HANDLE_CLASS,LPVOID,DWORD))aSyscall[65].pCurrent)
         FILE_INFO_BY_HANDLE_CLASS,LPVOID,DWORD))aSyscall[66].pCurrent)
 #if SQLITE_OS_WINRT && !defined(SQLITE_OMIT_WAL)
   { "MapViewOfFileFromApp",    (SYSCALL)MapViewOfFileFromApp,    0 },

@@ -31744,7 +32333,7 @@ static struct win_syscall {

 #endif
 #define osMapViewOfFileFromApp ((LPVOID(WINAPI*)(HANDLE,ULONG,ULONG64, \
         SIZE_T))aSyscall[66].pCurrent)
         SIZE_T))aSyscall[67].pCurrent)
 #if SQLITE_OS_WINRT
   { "CreateFile2",             (SYSCALL)CreateFile2,             0 },

@@ -31753,7 +32342,7 @@ static struct win_syscall {

 #endif
 #define osCreateFile2 ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD,DWORD, \
         LPCREATEFILE2_EXTENDED_PARAMETERS))aSyscall[67].pCurrent)
         LPCREATEFILE2_EXTENDED_PARAMETERS))aSyscall[68].pCurrent)
 #if SQLITE_OS_WINRT && !defined(SQLITE_OMIT_LOAD_EXTENSION)
   { "LoadPackagedLibrary",     (SYSCALL)LoadPackagedLibrary,     0 },

@@ -31762,7 +32351,7 @@ static struct win_syscall {

 #endif
 #define osLoadPackagedLibrary ((HMODULE(WINAPI*)(LPCWSTR, \
         DWORD))aSyscall[68].pCurrent)
         DWORD))aSyscall[69].pCurrent)
 #if SQLITE_OS_WINRT
   { "GetTickCount64",          (SYSCALL)GetTickCount64,          0 },

@@ -31770,7 +32359,7 @@ static struct win_syscall {

   { "GetTickCount64",          (SYSCALL)0,                       0 },
 #endif
 #define osGetTickCount64 ((ULONGLONG(WINAPI*)(VOID))aSyscall[69].pCurrent)
 #define osGetTickCount64 ((ULONGLONG(WINAPI*)(VOID))aSyscall[70].pCurrent)
 #if SQLITE_OS_WINRT
   { "GetNativeSystemInfo",     (SYSCALL)GetNativeSystemInfo,     0 },

@@ -31779,7 +32368,7 @@ static struct win_syscall {

 #endif
 #define osGetNativeSystemInfo ((VOID(WINAPI*)( \
         LPSYSTEM_INFO))aSyscall[70].pCurrent)
         LPSYSTEM_INFO))aSyscall[71].pCurrent)
 #if defined(SQLITE_WIN32_HAS_ANSI)
   { "OutputDebugStringA",      (SYSCALL)OutputDebugStringA,      0 },

@@ -31787,7 +32376,7 @@ static struct win_syscall {

   { "OutputDebugStringA",      (SYSCALL)0,                       0 },
 #endif
 #define osOutputDebugStringA ((VOID(WINAPI*)(LPCSTR))aSyscall[71].pCurrent)
 #define osOutputDebugStringA ((VOID(WINAPI*)(LPCSTR))aSyscall[72].pCurrent)
 #if defined(SQLITE_WIN32_HAS_WIDE)
   { "OutputDebugStringW",      (SYSCALL)OutputDebugStringW,      0 },

@@ -31795,11 +32384,11 @@ static struct win_syscall {

   { "OutputDebugStringW",      (SYSCALL)0,                       0 },
 #endif
 #define osOutputDebugStringW ((VOID(WINAPI*)(LPCWSTR))aSyscall[72].pCurrent)
 #define osOutputDebugStringW ((VOID(WINAPI*)(LPCWSTR))aSyscall[73].pCurrent)
   { "GetProcessHeap",          (SYSCALL)GetProcessHeap,          0 },
 #define osGetProcessHeap ((HANDLE(WINAPI*)(VOID))aSyscall[73].pCurrent)
 #define osGetProcessHeap ((HANDLE(WINAPI*)(VOID))aSyscall[74].pCurrent)
 #if SQLITE_OS_WINRT && !defined(SQLITE_OMIT_WAL)
   { "CreateFileMappingFromApp", (SYSCALL)CreateFileMappingFromApp, 0 },

@@ -31808,7 +32397,7 @@ static struct win_syscall {

 #endif
 #define osCreateFileMappingFromApp ((HANDLE(WINAPI*)(HANDLE, \
         LPSECURITY_ATTRIBUTES,ULONG,ULONG64,LPCWSTR))aSyscall[74].pCurrent)
         LPSECURITY_ATTRIBUTES,ULONG,ULONG64,LPCWSTR))aSyscall[75].pCurrent)
 }; /* End of the overrideable system calls */

@@ -31895,6 +32484,94 @@ static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){

   return 0;
 }
 #ifdef SQLITE_WIN32_MALLOC
 /*
 ** If a Win32 native heap has been configured, this function will attempt to
 ** compact it.  Upon success, SQLITE_OK will be returned.  Upon failure, one
 ** of SQLITE_NOMEM, SQLITE_ERROR, or SQLITE_NOTFOUND will be returned.  The
 ** "pnLargest" argument, if non-zero, will be used to return the size of the
 ** largest committed free block in the heap, in bytes.
 */
 SQLITE_API int sqlite3_win32_compact_heap(LPUINT pnLargest){
   int rc = SQLITE_OK;
   UINT nLargest = 0;
   HANDLE hHeap;
   winMemAssertMagic();
   hHeap = winMemGetHeap();
   assert( hHeap!=0 );
   assert( hHeap!=INVALID_HANDLE_VALUE );
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE)
   assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
 #endif
 #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
   if( (nLargest=osHeapCompact(hHeap, SQLITE_WIN32_HEAP_FLAGS))==0 ){
     DWORD lastErrno = osGetLastError();
     if( lastErrno==NO_ERROR ){
       sqlite3_log(SQLITE_NOMEM, "failed to HeapCompact (no space), heap=%p",
                   (void*)hHeap);
       rc = SQLITE_NOMEM;
     }else{
       sqlite3_log(SQLITE_ERROR, "failed to HeapCompact (%lu), heap=%p",
                   osGetLastError(), (void*)hHeap);
       rc = SQLITE_ERROR;
     }
   }
 #else
   sqlite3_log(SQLITE_NOTFOUND, "failed to HeapCompact, heap=%p",
               (void*)hHeap);
   rc = SQLITE_NOTFOUND;
 #endif
   if( pnLargest ) *pnLargest = nLargest;
   return rc;
 }
 /*
 ** If a Win32 native heap has been configured, this function will attempt to
 ** destroy and recreate it.  If the Win32 native heap is not isolated and/or
 ** the sqlite3_memory_used() function does not return zero, SQLITE_BUSY will
 ** be returned and no changes will be made to the Win32 native heap.
 */
 SQLITE_API int sqlite3_win32_reset_heap(){
   int rc;
   MUTEX_LOGIC( sqlite3_mutex *pMaster; ) /* The main static mutex */
   MUTEX_LOGIC( sqlite3_mutex *pMem; )    /* The memsys static mutex */
   MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
   MUTEX_LOGIC( pMem = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); )
   sqlite3_mutex_enter(pMaster);
   sqlite3_mutex_enter(pMem);
   winMemAssertMagic();
   if( winMemGetHeap()!=NULL && winMemGetOwned() && sqlite3_memory_used()==0 ){
     /*
     ** At this point, there should be no outstanding memory allocations on
     ** the heap.  Also, since both the master and memsys locks are currently
     ** being held by us, no other function (i.e. from another thread) should
     ** be able to even access the heap.  Attempt to destroy and recreate our
     ** isolated Win32 native heap now.
     */
     assert( winMemGetHeap()!=NULL );
     assert( winMemGetOwned() );
     assert( sqlite3_memory_used()==0 );
     winMemShutdown(winMemGetDataPtr());
     assert( winMemGetHeap()==NULL );
     assert( !winMemGetOwned() );
     assert( sqlite3_memory_used()==0 );
     rc = winMemInit(winMemGetDataPtr());
     assert( rc!=SQLITE_OK || winMemGetHeap()!=NULL );
     assert( rc!=SQLITE_OK || winMemGetOwned() );
     assert( rc!=SQLITE_OK || sqlite3_memory_used()==0 );
   }else{
     /*
     ** The Win32 native heap cannot be modified because it may be in use.
     */
     rc = SQLITE_BUSY;
   }
   sqlite3_mutex_leave(pMem);
   sqlite3_mutex_leave(pMaster);
   return rc;
 }
 #endif /* SQLITE_WIN32_MALLOC */
 /*
 ** This function outputs the specified (ANSI) string to the Win32 debugger
 ** (if available).

@@ -31964,11 +32641,10 @@ SQLITE_API void sqlite3_win32_sleep(DWORD milliseconds){

 ** WinNT/2K/XP so that we will know whether or not we can safely call
 ** the LockFileEx() API.
 */
 #ifndef NTDDI_WIN8
 #  define NTDDI_WIN8                        0x06020000
 #endif
 #if SQLITE_OS_WINCE || SQLITE_OS_WINRT || !defined(SQLITE_WIN32_HAS_ANSI)
 #if !defined(SQLITE_WIN32_GETVERSIONEX) || !SQLITE_WIN32_GETVERSIONEX
 # define osIsNT()  (1)
 #elif SQLITE_OS_WINCE || SQLITE_OS_WINRT || !defined(SQLITE_WIN32_HAS_ANSI)
 # define osIsNT()  (1)
 #elif !defined(SQLITE_WIN32_HAS_WIDE)
 # define osIsNT()  (0)

@@ -32003,7 +32679,7 @@ static void *winMemMalloc(int nBytes){

   assert( hHeap!=0 );
   assert( hHeap!=INVALID_HANDLE_VALUE );
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE)
   assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
   assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
 #endif
   assert( nBytes>=0 );
   p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);

@@ -32025,7 +32701,7 @@ static void winMemFree(void *pPrior){

   assert( hHeap!=0 );
   assert( hHeap!=INVALID_HANDLE_VALUE );
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE)
   assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
   assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
 #endif
   if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */
   if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){

@@ -32046,7 +32722,7 @@ static void *winMemRealloc(void *pPrior, int nBytes){

   assert( hHeap!=0 );
   assert( hHeap!=INVALID_HANDLE_VALUE );
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE)
   assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
   assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
 #endif
   assert( nBytes>=0 );
   if( !pPrior ){

@@ -32074,7 +32750,7 @@ static int winMemSize(void *p){

   assert( hHeap!=0 );
   assert( hHeap!=INVALID_HANDLE_VALUE );
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE)
   assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
   assert( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, p) );
 #endif
   if( !p ) return 0;
   n = osHeapSize(hHeap, SQLITE_WIN32_HEAP_FLAGS, p);

@@ -32100,18 +32776,25 @@ static int winMemInit(void *pAppData){

   winMemData *pWinMemData = (winMemData *)pAppData;
   if( !pWinMemData ) return SQLITE_ERROR;
   assert( pWinMemData->magic==WINMEM_MAGIC );
   assert( pWinMemData->magic1==WINMEM_MAGIC1 );
   assert( pWinMemData->magic2==WINMEM_MAGIC2 );
 #if !SQLITE_OS_WINRT && SQLITE_WIN32_HEAP_CREATE
   if( !pWinMemData->hHeap ){
     DWORD dwInitialSize = SQLITE_WIN32_HEAP_INIT_SIZE;
     DWORD dwMaximumSize = (DWORD)sqlite3GlobalConfig.nHeap;
     if( dwMaximumSize==0 ){
       dwMaximumSize = SQLITE_WIN32_HEAP_MAX_SIZE;
     }else if( dwInitialSize>dwMaximumSize ){
       dwInitialSize = dwMaximumSize;
     }
     pWinMemData->hHeap = osHeapCreate(SQLITE_WIN32_HEAP_FLAGS,
                                       SQLITE_WIN32_HEAP_INIT_SIZE,
                                       SQLITE_WIN32_HEAP_MAX_SIZE);
                                       dwInitialSize, dwMaximumSize);
     if( !pWinMemData->hHeap ){
       sqlite3_log(SQLITE_NOMEM,
           "failed to HeapCreate (%lu), flags=%u, initSize=%u, maxSize=%u",
           osGetLastError(), SQLITE_WIN32_HEAP_FLAGS,
           SQLITE_WIN32_HEAP_INIT_SIZE, SQLITE_WIN32_HEAP_MAX_SIZE);
           "failed to HeapCreate (%lu), flags=%u, initSize=%lu, maxSize=%lu",
           osGetLastError(), SQLITE_WIN32_HEAP_FLAGS, dwInitialSize,
           dwMaximumSize);
       return SQLITE_NOMEM;
     }
     pWinMemData->bOwned = TRUE;

@@ -32142,6 +32825,9 @@ static void winMemShutdown(void *pAppData){

   winMemData *pWinMemData = (winMemData *)pAppData;
   if( !pWinMemData ) return;
   assert( pWinMemData->magic1==WINMEM_MAGIC1 );
   assert( pWinMemData->magic2==WINMEM_MAGIC2 );
   if( pWinMemData->hHeap ){
     assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_MALLOC_VALIDATE)

@@ -33784,7 +34470,7 @@ static int winFileControl(sqlite3_file *id, int op, void *pArg){

       return SQLITE_OK;
     }
     case SQLITE_FCNTL_VFSNAME: {
       *(char**)pArg = sqlite3_mprintf("win32");
       *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
       OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
       return SQLITE_OK;
     }

@@ -33866,7 +34552,7 @@ static int winDeviceCharacteristics(sqlite3_file *id){

 ** During sqlite3_os_init() we do a GetSystemInfo()
 ** to get the granularity size.
 */
 SYSTEM_INFO winSysInfo;
 static SYSTEM_INFO winSysInfo;
 #ifndef SQLITE_OMIT_WAL

@@ -33889,7 +34575,7 @@ static void winShmEnterMutex(void){

 static void winShmLeaveMutex(void){
   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
 }
 #ifdef SQLITE_DEBUG
 #ifndef NDEBUG
 static int winShmMutexHeld(void) {
   return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
 }

@@ -34768,7 +35454,7 @@ static const sqlite3_io_methods winIoMethod = {

 ** sqlite3_vfs object.
 */
 #if 0
 #if defined(__CYGWIN__)
 /*
 ** Convert a filename from whatever the underlying operating system
 ** supports for filenames into UTF-8.  Space to hold the result is

@@ -34811,12 +35497,21 @@ static void *winConvertFromUtf8Filename(const char *zFilename){

 /*
 ** This function returns non-zero if the specified UTF-8 string buffer
 ** ends with a directory separator character.
 ** ends with a directory separator character or one was successfully
 ** added to it.
 */
 static int winEndsInDirSep(char *zBuf){
 static int winMakeEndInDirSep(int nBuf, char *zBuf){
   if( zBuf ){
     int nLen = sqlite3Strlen30(zBuf);
     return nLen>0 && winIsDirSep(zBuf[nLen-1]);
     if( nLen>0 ){
       if( winIsDirSep(zBuf[nLen-1]) ){
         return 1;
       }else if( nLen+1<nBuf ){
         zBuf[nLen] = winGetDirSep();
         zBuf[nLen+1] = '\0';
         return 1;
       }
     }
   }
   return 0;
 }

@@ -34831,7 +35526,8 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){

     "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     "0123456789";
   size_t i, j;
   int nBuf, nLen;
   int nPre = sqlite3Strlen30(SQLITE_TEMP_FILE_PREFIX);
   int nMax, nBuf, nDir, nLen;
   char *zBuf;
   /* It's odd to simulate an io-error here, but really this is just

@@ -34843,8 +35539,8 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){

   /* Allocate a temporary buffer to store the fully qualified file
   ** name for the temporary file.  If this fails, we cannot continue.
   */
   nBuf = pVfs->mxPathname;
   zBuf = sqlite3MallocZero( nBuf+2 );
   nMax = pVfs->mxPathname; nBuf = nMax + 2;
   zBuf = sqlite3MallocZero( nBuf );
   if( !zBuf ){
     OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
     return SQLITE_IOERR_NOMEM;

@@ -34854,11 +35550,21 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){

   ** has been explicitly set by the application; otherwise, use the one
   ** configured by the operating system.
   */
   assert( nBuf>30 );
   nDir = nMax - (nPre + 15);
   assert( nDir>0 );
   if( sqlite3_temp_directory ){
     sqlite3_snprintf(nBuf-30, zBuf, "%s%s", sqlite3_temp_directory,
                      winEndsInDirSep(sqlite3_temp_directory) ? "" :
                      winGetDirDep());
     int nDirLen = sqlite3Strlen30(sqlite3_temp_directory);
     if( nDirLen>0 ){
       if( !winIsDirSep(sqlite3_temp_directory[nDirLen-1]) ){
         nDirLen++;
       }
       if( nDirLen>nDir ){
         sqlite3_free(zBuf);
         OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n"));
         return winLogError(SQLITE_ERROR, 0, "winGetTempname1", 0);
       }
       sqlite3_snprintf(nMax, zBuf, "%s", sqlite3_temp_directory);
     }
   }
 #if defined(__CYGWIN__)
   else{

@@ -34887,8 +35593,8 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){

       if( zDir==0 ) continue;
       /* If the path starts with a drive letter followed by the colon
       ** character, assume it is already a native Win32 path; otherwise,
       ** it must be converted to a native Win32 path prior via the Cygwin
       ** API prior to using it.
       ** it must be converted to a native Win32 path via the Cygwin API
       ** prior to using it.
       */
       if( winIsDriveLetterAndColon(zDir) ){
         zConverted = winConvertFromUtf8Filename(zDir);

@@ -34898,13 +35604,13 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){

           return SQLITE_IOERR_NOMEM;
         }
         if( winIsDir(zConverted) ){
           sqlite3_snprintf(nBuf-30, zBuf, "%s", zDir);
           sqlite3_snprintf(nMax, zBuf, "%s", zDir);
           sqlite3_free(zConverted);
           break;
         }
         sqlite3_free(zConverted);
       }else{
         zConverted = sqlite3MallocZero( nBuf+1 );
         zConverted = sqlite3MallocZero( nMax+1 );
         if( !zConverted ){
           sqlite3_free(zBuf);
           OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));

@@ -34912,35 +35618,29 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){

         }
         if( cygwin_conv_path(
                 osIsNT() ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_A, zDir,
                 zConverted, nBuf+1)<0 ){
                 zConverted, nMax+1)<0 ){
           sqlite3_free(zConverted);
           sqlite3_free(zBuf);
           OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_CONVPATH\n"));
           return winLogError(SQLITE_IOERR_CONVPATH, (DWORD)errno,
                              "winGetTempname1", zDir);
                              "winGetTempname2", zDir);
         }
         if( winIsDir(zConverted) ){
           /* At this point, we know the candidate directory exists and should
           ** be used.  However, we may need to convert the string containing
           ** its name into UTF-8 (i.e. if it is UTF-16 right now).
           */
           if( osIsNT() ){
             char *zUtf8 = winUnicodeToUtf8(zConverted);
             if( !zUtf8 ){
               sqlite3_free(zConverted);
               sqlite3_free(zBuf);
               OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
               return SQLITE_IOERR_NOMEM;
             }
             sqlite3_snprintf(nBuf-30, zBuf, "%s", zUtf8);
             sqlite3_free(zUtf8);
             sqlite3_free(zConverted);
             break;
           }else{
             sqlite3_snprintf(nBuf-30, zBuf, "%s", zConverted);
           char *zUtf8 = winConvertToUtf8Filename(zConverted);
           if( !zUtf8 ){
             sqlite3_free(zConverted);
             break;
             sqlite3_free(zBuf);
             OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
             return SQLITE_IOERR_NOMEM;
           }
           sqlite3_snprintf(nMax, zBuf, "%s", zUtf8);
           sqlite3_free(zUtf8);
           sqlite3_free(zConverted);
           break;
         }
         sqlite3_free(zConverted);
       }

@@ -34949,22 +35649,22 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){

 #elif !SQLITE_OS_WINRT && !defined(__CYGWIN__)
   else if( osIsNT() ){
     char *zMulti;
     LPWSTR zWidePath = sqlite3MallocZero( nBuf*sizeof(WCHAR) );
     LPWSTR zWidePath = sqlite3MallocZero( nMax*sizeof(WCHAR) );
     if( !zWidePath ){
       sqlite3_free(zBuf);
       OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
       return SQLITE_IOERR_NOMEM;
     }
     if( osGetTempPathW(nBuf, zWidePath)==0 ){
     if( osGetTempPathW(nMax, zWidePath)==0 ){
       sqlite3_free(zWidePath);
       sqlite3_free(zBuf);
       OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_GETTEMPPATH\n"));
       return winLogError(SQLITE_IOERR_GETTEMPPATH, osGetLastError(),
                          "winGetTempname1", 0);
                          "winGetTempname2", 0);
     }
     zMulti = winUnicodeToUtf8(zWidePath);
     if( zMulti ){
       sqlite3_snprintf(nBuf-30, zBuf, "%s", zMulti);
       sqlite3_snprintf(nMax, zBuf, "%s", zMulti);
       sqlite3_free(zMulti);
       sqlite3_free(zWidePath);
     }else{

@@ -34977,21 +35677,21 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){

 #ifdef SQLITE_WIN32_HAS_ANSI
   else{
     char *zUtf8;
     char *zMbcsPath = sqlite3MallocZero( nBuf );
     char *zMbcsPath = sqlite3MallocZero( nMax );
     if( !zMbcsPath ){
       sqlite3_free(zBuf);
       OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_NOMEM\n"));
       return SQLITE_IOERR_NOMEM;
     }
     if( osGetTempPathA(nBuf, zMbcsPath)==0 ){
     if( osGetTempPathA(nMax, zMbcsPath)==0 ){
       sqlite3_free(zBuf);
       OSTRACE(("TEMP-FILENAME rc=SQLITE_IOERR_GETTEMPPATH\n"));
       return winLogError(SQLITE_IOERR_GETTEMPPATH, osGetLastError(),
                          "winGetTempname2", 0);
                          "winGetTempname3", 0);
     }
     zUtf8 = sqlite3_win32_mbcs_to_utf8(zMbcsPath);
     if( zUtf8 ){
       sqlite3_snprintf(nBuf-30, zBuf, "%s", zUtf8);
       sqlite3_snprintf(nMax, zBuf, "%s", zUtf8);
       sqlite3_free(zUtf8);
     }else{
       sqlite3_free(zBuf);

@@ -35002,18 +35702,36 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){

 #endif /* SQLITE_WIN32_HAS_ANSI */
 #endif /* !SQLITE_OS_WINRT */
   /* Check that the output buffer is large enough for the temporary file
   ** name. If it is not, return SQLITE_ERROR.
   /*
   ** Check to make sure the temporary directory ends with an appropriate
   ** separator.  If it does not and there is not enough space left to add
   ** one, fail.
   */
   nLen = sqlite3Strlen30(zBuf);
   if( !winMakeEndInDirSep(nDir+1, zBuf) ){
     sqlite3_free(zBuf);
     OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n"));
     return winLogError(SQLITE_ERROR, 0, "winGetTempname4", 0);
   }
   if( (nLen + sqlite3Strlen30(SQLITE_TEMP_FILE_PREFIX) + 18) >= nBuf ){
   /*
   ** Check that the output buffer is large enough for the temporary file
   ** name in the following format:
   **
   **   "<temporary_directory>/etilqs_XXXXXXXXXXXXXXX\0\0"
   **
   ** If not, return SQLITE_ERROR.  The number 17 is used here in order to
   ** account for the space used by the 15 character random suffix and the
   ** two trailing NUL characters.  The final directory separator character
   ** has already added if it was not already present.
   */
   nLen = sqlite3Strlen30(zBuf);
   if( (nLen + nPre + 17) > nBuf ){
     sqlite3_free(zBuf);
     OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n"));
     return winLogError(SQLITE_ERROR, 0, "winGetTempname3", 0);
     return winLogError(SQLITE_ERROR, 0, "winGetTempname5", 0);
   }
   sqlite3_snprintf(nBuf-18-nLen, zBuf+nLen, SQLITE_TEMP_FILE_PREFIX);
   sqlite3_snprintf(nBuf-16-nLen, zBuf+nLen, SQLITE_TEMP_FILE_PREFIX);
   j = sqlite3Strlen30(zBuf);
   sqlite3_randomness(15, &zBuf[j]);

@@ -35068,7 +35786,7 @@ static int winOpen(

   int *pOutFlags            /* Status return flags */
 ){
   HANDLE h;
   DWORD lastErrno;
   DWORD lastErrno = 0;
   DWORD dwDesiredAccess;
   DWORD dwShareMode;
   DWORD dwCreationDisposition;

@@ -35359,7 +36077,7 @@ static int winDelete(

   int cnt = 0;
   int rc;
   DWORD attr;
   DWORD lastErrno;
   DWORD lastErrno = 0;
   void *zConverted;
   UNUSED_PARAMETER(pVfs);
   UNUSED_PARAMETER(syncDir);

@@ -35467,7 +36185,7 @@ static int winAccess(

 ){
   DWORD attr;
   int rc = 0;
   DWORD lastErrno;
   DWORD lastErrno = 0;
   void *zConverted;
   UNUSED_PARAMETER(pVfs);

@@ -35607,19 +36325,43 @@ static int winFullPathname(

     if( !zOut ){
       return SQLITE_IOERR_NOMEM;
     }
     if( cygwin_conv_path(CCP_POSIX_TO_WIN_A|CCP_RELATIVE, zRelative, zOut,
                          pVfs->mxPathname+1)<0 ){
     if( cygwin_conv_path(
             (osIsNT() ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_A) |
             CCP_RELATIVE, zRelative, zOut, pVfs->mxPathname+1)<0 ){
       sqlite3_free(zOut);
       return winLogError(SQLITE_CANTOPEN_CONVPATH, (DWORD)errno,
                          "winFullPathname1", zRelative);
     }else{
       char *zUtf8 = winConvertToUtf8Filename(zOut);
       if( !zUtf8 ){
         sqlite3_free(zOut);
         return SQLITE_IOERR_NOMEM;
       }
       sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s",
                        sqlite3_data_directory, winGetDirSep(), zUtf8);
       sqlite3_free(zUtf8);
       sqlite3_free(zOut);
     }
     sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%s%s",
                      sqlite3_data_directory, winGetDirDep(), zOut);
     sqlite3_free(zOut);
   }else{
     if( cygwin_conv_path(CCP_POSIX_TO_WIN_A, zRelative, zFull, nFull)<0 ){
     char *zOut = sqlite3MallocZero( pVfs->mxPathname+1 );
     if( !zOut ){
       return SQLITE_IOERR_NOMEM;
     }
     if( cygwin_conv_path(
             (osIsNT() ? CCP_POSIX_TO_WIN_W : CCP_POSIX_TO_WIN_A),
             zRelative, zOut, pVfs->mxPathname+1)<0 ){
       sqlite3_free(zOut);
       return winLogError(SQLITE_CANTOPEN_CONVPATH, (DWORD)errno,
                          "winFullPathname2", zRelative);
     }else{
       char *zUtf8 = winConvertToUtf8Filename(zOut);
       if( !zUtf8 ){
         sqlite3_free(zOut);
         return SQLITE_IOERR_NOMEM;
       }
       sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zUtf8);
       sqlite3_free(zUtf8);
       sqlite3_free(zOut);
     }
   }
   return SQLITE_OK;

@@ -35636,8 +36378,8 @@ static int winFullPathname(

     **       for converting the relative path name to an absolute
     **       one by prepending the data directory and a backslash.
     */
     sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%s%s",
                      sqlite3_data_directory, winGetDirDep(), zRelative);
     sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s",
                      sqlite3_data_directory, winGetDirSep(), zRelative);
   }else{
     sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s", zRelative);
   }

@@ -35669,8 +36411,8 @@ static int winFullPathname(

     **       for converting the relative path name to an absolute
     **       one by prepending the data directory and a backslash.
     */
     sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%s%s",
                      sqlite3_data_directory, winGetDirDep(), zRelative);
     sqlite3_snprintf(MIN(nFull, pVfs->mxPathname), zFull, "%s%c%s",
                      sqlite3_data_directory, winGetDirSep(), zRelative);
     return SQLITE_OK;
   }
   zConverted = winConvertFromUtf8Filename(zRelative);

@@ -35744,15 +36486,29 @@ static int winFullPathname(

 ** Interfaces for opening a shared library, finding entry points
 ** within the shared library, and closing the shared library.
 */
 /*
 ** Interfaces for opening a shared library, finding entry points
 ** within the shared library, and closing the shared library.
 */
 static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
   HANDLE h;
 #if defined(__CYGWIN__)
   int nFull = pVfs->mxPathname+1;
   char *zFull = sqlite3MallocZero( nFull );
   void *zConverted = 0;
   if( zFull==0 ){
     OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0));
     return 0;
   }
   if( winFullPathname(pVfs, zFilename, nFull, zFull)!=SQLITE_OK ){
     sqlite3_free(zFull);
     OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0));
     return 0;
   }
   zConverted = winConvertFromUtf8Filename(zFull);
   sqlite3_free(zFull);
 #else
   void *zConverted = winConvertFromUtf8Filename(zFilename);
   UNUSED_PARAMETER(pVfs);
 #endif
   if( zConverted==0 ){
     OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)0));
     return 0;
   }
   if( osIsNT() ){

@@ -35767,6 +36523,7 @@ static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){

     h = osLoadLibraryA((char*)zConverted);
   }
 #endif
   OSTRACE(("DLOPEN name=%s, handle=%p\n", zFilename, (void*)h));
   sqlite3_free(zConverted);
   return (void*)h;
 }

@@ -35775,12 +36532,17 @@ static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){

   winGetLastErrorMsg(osGetLastError(), nBuf, zBufOut);
 }
 static void (*winDlSym(sqlite3_vfs *pVfs,void *pH,const char *zSym))(void){
   FARPROC proc;
   UNUSED_PARAMETER(pVfs);
   return (void(*)(void))osGetProcAddressA((HANDLE)pH, zSym);
   proc = osGetProcAddressA((HANDLE)pH, zSym);
   OSTRACE(("DLSYM handle=%p, symbol=%s, address=%p\n",
            (void*)pH, zSym, (void*)proc));
   return (void(*)(void))proc;
 }
 static void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
   UNUSED_PARAMETER(pVfs);
   osFreeLibrary((HANDLE)pHandle);
   OSTRACE(("DLCLOSE handle=%p\n", (void*)pHandle));
 }
 #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
   #define winDlOpen  0

@@ -36008,7 +36770,7 @@ SQLITE_API int sqlite3_os_init(void){

   /* Double-check that the aSyscall[] array has been constructed
   ** correctly.  See ticket [bb3a86e890c8e96ab] */
   assert( ArraySize(aSyscall)==75 );
   assert( ArraySize(aSyscall)==76 );
   /* get memory map allocation granularity */
   memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));

@@ -36476,7 +37238,8 @@ struct PCache {

   int szCache;                        /* Configured cache size */
   int szPage;                         /* Size of every page in this cache */
   int szExtra;                        /* Size of extra space for each page */
   int bPurgeable;                     /* True if pages are on backing store */
   u8 bPurgeable;                      /* True if pages are on backing store */
   u8 eCreate;                         /* eCreate value for for xFetch() */
   int (*xStress)(void*,PgHdr*);       /* Call to try make a page clean */
   void *pStress;                      /* Argument to xStress */
   sqlite3_pcache *pCache;             /* Pluggable cache module */

@@ -36543,6 +37306,10 @@ static void pcacheRemoveFromDirtyList(PgHdr *pPage){

   }else{
     assert( pPage==p->pDirty );
     p->pDirty = pPage->pDirtyNext;
     if( p->pDirty==0 && p->bPurgeable ){
       assert( p->eCreate==1 );
       p->eCreate = 2;
     }
   }
   pPage->pDirtyNext = 0;
   pPage->pDirtyPrev = 0;

@@ -36563,6 +37330,9 @@ static void pcacheAddToDirtyList(PgHdr *pPage){

   if( pPage->pDirtyNext ){
     assert( pPage->pDirtyNext->pDirtyPrev==0 );
     pPage->pDirtyNext->pDirtyPrev = pPage;
   }else if( p->bPurgeable ){
     assert( p->eCreate==2 );
     p->eCreate = 1;
   }
   p->pDirty = pPage;
   if( !p->pDirtyTail ){

@@ -36632,6 +37402,7 @@ SQLITE_PRIVATE void sqlite3PcacheOpen(

   p->szPage = szPage;
   p->szExtra = szExtra;
   p->bPurgeable = bPurgeable;
   p->eCreate = 2;
   p->xStress = xStress;
   p->pStress = pStress;
   p->szCache = 100;

@@ -36671,7 +37442,7 @@ SQLITE_PRIVATE int sqlite3PcacheFetch(

   int createFlag,       /* If true, create page if it does not exist already */
   PgHdr **ppPage        /* Write the page here */
 ){
   sqlite3_pcache_page *pPage = 0;
   sqlite3_pcache_page *pPage;
   PgHdr *pPgHdr = 0;
   int eCreate;

@@ -36682,8 +37453,12 @@ SQLITE_PRIVATE int sqlite3PcacheFetch(

   /* If the pluggable cache (sqlite3_pcache*) has not been allocated,
   ** allocate it now.
   */
   if( !pCache->pCache && createFlag ){
   if( !pCache->pCache ){
     sqlite3_pcache *p;
     if( !createFlag ){
       *ppPage = 0;
       return SQLITE_OK;
     }
     p = sqlite3GlobalConfig.pcache2.xCreate(
         pCache->szPage, pCache->szExtra + sizeof(PgHdr), pCache->bPurgeable
     );

@@ -36694,11 +37469,16 @@ SQLITE_PRIVATE int sqlite3PcacheFetch(

     pCache->pCache = p;
   }
   eCreate = createFlag * (1 + (!pCache->bPurgeable || !pCache->pDirty));
   if( pCache->pCache ){
     pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate);
   }
   /* eCreate defines what to do if the page does not exist.
   **    0     Do not allocate a new page.  (createFlag==0)
   **    1     Allocate a new page if doing so is inexpensive.
   **          (createFlag==1 AND bPurgeable AND pDirty)
   **    2     Allocate a new page even it doing so is difficult.
   **          (createFlag==1 AND !(bPurgeable AND pDirty)
   */
   eCreate = createFlag==0 ? 0 : pCache->eCreate;
   assert( (createFlag*(1+(!pCache->bPurgeable||!pCache->pDirty)))==eCreate );
   pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate);
   if( !pPage && eCreate==1 ){
     PgHdr *pPg;

@@ -37170,6 +37950,7 @@ struct PCache1 {

 struct PgHdr1 {
   sqlite3_pcache_page page;
   unsigned int iKey;             /* Key value (page number) */
   u8 isPinned;                   /* Page in use, not on the LRU list */
   PgHdr1 *pNext;                 /* Next in hash table chain */
   PCache1 *pCache;               /* Cache that currently owns this page */
   PgHdr1 *pLruNext;              /* Next in LRU list of unpinned pages */

@@ -37498,34 +38279,32 @@ static int pcache1ResizeHash(PCache1 *p){

 ** LRU list, then this function is a no-op.
 **
 ** The PGroup mutex must be held when this function is called.
 **
 ** If pPage is NULL then this routine is a no-op.
 */
 static void pcache1PinPage(PgHdr1 *pPage){
   PCache1 *pCache;
   PGroup *pGroup;
   if( pPage==0 ) return;
   assert( pPage!=0 );
   assert( pPage->isPinned==0 );
   pCache = pPage->pCache;
   pGroup = pCache->pGroup;
   assert( pPage->pLruNext || pPage==pGroup->pLruTail );
   assert( pPage->pLruPrev || pPage==pGroup->pLruHead );
   assert( sqlite3_mutex_held(pGroup->mutex) );
   if( pPage->pLruNext || pPage==pGroup->pLruTail ){
     if( pPage->pLruPrev ){
       pPage->pLruPrev->pLruNext = pPage->pLruNext;
     }
     if( pPage->pLruNext ){
       pPage->pLruNext->pLruPrev = pPage->pLruPrev;
     }
     if( pGroup->pLruHead==pPage ){
       pGroup->pLruHead = pPage->pLruNext;
     }
     if( pGroup->pLruTail==pPage ){
       pGroup->pLruTail = pPage->pLruPrev;
     }
     pPage->pLruNext = 0;
     pPage->pLruPrev = 0;
     pPage->pCache->nRecyclable--;
   if( pPage->pLruPrev ){
     pPage->pLruPrev->pLruNext = pPage->pLruNext;
   }else{
     pGroup->pLruHead = pPage->pLruNext;
   }
   if( pPage->pLruNext ){
     pPage->pLruNext->pLruPrev = pPage->pLruPrev;
   }else{
     pGroup->pLruTail = pPage->pLruPrev;
   }
   pPage->pLruNext = 0;
   pPage->pLruPrev = 0;
   pPage->isPinned = 1;
   pCache->nRecyclable--;
 }

@@ -37557,6 +38336,7 @@ static void pcache1EnforceMaxPage(PGroup *pGroup){

   while( pGroup->nCurrentPage>pGroup->nMaxPage && pGroup->pLruTail ){
     PgHdr1 *p = pGroup->pLruTail;
     assert( p->pCache->pGroup==pGroup );
     assert( p->isPinned==0 );
     pcache1PinPage(p);
     pcache1RemoveFromHash(p);
     pcache1FreePage(p);

@@ -37584,7 +38364,7 @@ static void pcache1TruncateUnsafe(

       if( pPage->iKey>=iLimit ){
         pCache->nPage--;
         *pp = pPage->pNext;
         pcache1PinPage(pPage);
         if( !pPage->isPinned ) pcache1PinPage(pPage);
         pcache1FreePage(pPage);
       }else{
         pp = &pPage->pNext;

@@ -37794,6 +38574,7 @@ static sqlite3_pcache_page *pcache1Fetch(

   PGroup *pGroup;
   PgHdr1 *pPage = 0;
   assert( offsetof(PgHdr1,page)==0 );
   assert( pCache->bPurgeable || createFlag!=1 );
   assert( pCache->bPurgeable || pCache->nMin==0 );
   assert( pCache->bPurgeable==0 || pCache->nMin==10 );

@@ -37807,8 +38588,11 @@ static sqlite3_pcache_page *pcache1Fetch(

   }
   /* Step 2: Abort if no existing page is found and createFlag is 0 */
   if( pPage || createFlag==0 ){
     pcache1PinPage(pPage);
   if( pPage ){
     if( !pPage->isPinned ) pcache1PinPage(pPage);
     goto fetch_out;
   }
   if( createFlag==0 ){
     goto fetch_out;
   }

@@ -37849,6 +38633,7 @@ static sqlite3_pcache_page *pcache1Fetch(

   )){
     PCache1 *pOther;
     pPage = pGroup->pLruTail;
     assert( pPage->isPinned==0 );
     pcache1RemoveFromHash(pPage);
     pcache1PinPage(pPage);
     pOther = pPage->pCache;

@@ -37885,6 +38670,7 @@ static sqlite3_pcache_page *pcache1Fetch(

     pPage->pCache = pCache;
     pPage->pLruPrev = 0;
     pPage->pLruNext = 0;
     pPage->isPinned = 1;
     *(void **)pPage->page.pExtra = 0;
     pCache->apHash[h] = pPage;
   }

@@ -37894,7 +38680,7 @@ fetch_out:

     pCache->iMaxKey = iKey;
   }
   pcache1LeaveMutex(pGroup);
   return &pPage->page;
   return (sqlite3_pcache_page*)pPage;
 }

@@ -37920,6 +38706,7 @@ static void pcache1Unpin(

   */
   assert( pPage->pLruPrev==0 && pPage->pLruNext==0 );
   assert( pGroup->pLruHead!=pPage && pGroup->pLruTail!=pPage );
   assert( pPage->isPinned==1 );
   if( reuseUnlikely || pGroup->nCurrentPage>pGroup->nMaxPage ){
     pcache1RemoveFromHash(pPage);

@@ -37935,6 +38722,7 @@ static void pcache1Unpin(

       pGroup->pLruHead = pPage;
     }
     pCache->nRecyclable++;
     pPage->isPinned = 0;
   }
   pcache1LeaveMutex(pCache->pGroup);

@@ -38061,6 +38849,7 @@ SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int nReq){

 #ifdef SQLITE_PCACHE_SEPARATE_HEADER
       nFree += sqlite3MemSize(p);
 #endif
       assert( p->isPinned==0 );
       pcache1PinPage(p);
       pcache1RemoveFromHash(p);
       pcache1FreePage(p);

@@ -38085,6 +38874,7 @@ SQLITE_PRIVATE void sqlite3PcacheStats(

   PgHdr1 *p;
   int nRecyclable = 0;
   for(p=pcache1.grp.pLruHead; p; p=p->pLruNext){
     assert( p->isPinned==0 );
     nRecyclable++;
   }
   *pnCurrent = pcache1.grp.nCurrentPage;

@@ -39771,15 +40561,12 @@ static char *print_pager_state(Pager *p){

 static int subjRequiresPage(PgHdr *pPg){
   Pager *pPager = pPg->pPager;
   PagerSavepoint *p;
   Pgno pgno;
   Pgno pgno = pPg->pgno;
   int i;
   if( pPager->nSavepoint ){
     pgno = pPg->pgno;
     for(i=0; i<pPager->nSavepoint; i++){
       p = &pPager->aSavepoint[i];
       if( p->nOrig>=pgno && 0==sqlite3BitvecTest(p->pInSavepoint, pgno) ){
         return 1;
       }
   for(i=0; i<pPager->nSavepoint; i++){
     p = &pPager->aSavepoint[i];
     if( p->nOrig>=pgno && 0==sqlite3BitvecTest(p->pInSavepoint, pgno) ){
       return 1;
     }
   }
   return 0;

@@ -39788,8 +40575,8 @@ static int subjRequiresPage(PgHdr *pPg){

 /*
 ** Return true if the page is already in the journal file.
 */
 static int pageInJournal(PgHdr *pPg){
   return sqlite3BitvecTest(pPg->pPager->pInJournal, pPg->pgno);
 static int pageInJournal(Pager *pPager, PgHdr *pPg){
   return sqlite3BitvecTest(pPager->pInJournal, pPg->pgno);
 }
 /*

@@ -39996,6 +40783,7 @@ static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, u32 nMaster){

    || szJ<16
    || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
    || len>=nMaster
    || len==0
    || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
    || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
    || memcmp(aMagic, aJournalMagic, 8)

@@ -40432,7 +41220,7 @@ static int writeMasterJournal(Pager *pPager, const char *zMaster){

 ** already in memory.
 */
 static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
   PgHdr *p;                         /* Return value */
   PgHdr *p = 0;                     /* Return value */
   /* It is not possible for a call to PcacheFetch() with createFlag==0 to
   ** fail, since no attempt to allocate dynamic memory will be made.

@@ -40736,7 +41524,7 @@ static int pager_end_transaction(Pager *pPager, int hasMaster, int bCommit){

     PgHdr *p = pager_lookup(pPager, 1);
     if( p ){
       p->pageHash = 0;
       sqlite3PagerUnref(p);
       sqlite3PagerUnrefNotNull(p);
     }
   }
 #endif

@@ -40765,6 +41553,11 @@ static int pager_end_transaction(Pager *pPager, int hasMaster, int bCommit){

     rc = pager_truncate(pPager, pPager->dbSize);
   }
   if( rc==SQLITE_OK && bCommit && isOpen(pPager->fd) ){
     rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
     if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
   }
   if( !pPager->exclusiveMode
    && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
   ){

@@ -41578,7 +42371,7 @@ end_playback:

   if( rc==SQLITE_OK
    && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
   ){
     rc = sqlite3PagerSync(pPager);
     rc = sqlite3PagerSync(pPager, 0);
   }
   if( rc==SQLITE_OK ){
     rc = pager_end_transaction(pPager, zMaster[0]!='\0', 0);

@@ -41724,7 +42517,7 @@ static int pagerUndoCallback(void *pCtx, Pgno iPg){

       if( rc==SQLITE_OK ){
         pPager->xReiniter(pPg);
       }
       sqlite3PagerUnref(pPg);
       sqlite3PagerUnrefNotNull(pPg);
     }
   }

@@ -43079,7 +43872,7 @@ static int subjournalPage(PgHdr *pPg){

     assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
     assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
     assert( pagerUseWal(pPager)
          || pageInJournal(pPg)
          || pageInJournal(pPager, pPg)
          || pPg->pgno>pPager->dbOrigSize
     );
     rc = openSubJournal(pPager);

@@ -43544,6 +44337,30 @@ SQLITE_PRIVATE int sqlite3PagerOpen(

 }
 /* Verify that the database file has not be deleted or renamed out from
 ** under the pager.  Return SQLITE_OK if the database is still were it ought
 ** to be on disk.  Return non-zero (SQLITE_READONLY_DBMOVED or some other error
 ** code from sqlite3OsAccess()) if the database has gone missing.
 */
 static int databaseIsUnmoved(Pager *pPager){
   int bHasMoved = 0;
   int rc;
   if( pPager->tempFile ) return SQLITE_OK;
   if( pPager->dbSize==0 ) return SQLITE_OK;
   assert( pPager->zFilename && pPager->zFilename[0] );
   rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
   if( rc==SQLITE_NOTFOUND ){
     /* If the HAS_MOVED file-control is unimplemented, assume that the file
     ** has not been moved.  That is the historical behavior of SQLite: prior to
     ** version 3.8.3, it never checked */
     rc = SQLITE_OK;
   }else if( rc==SQLITE_OK && bHasMoved ){
     rc = SQLITE_READONLY_DBMOVED;
   }
   return rc;
 }
 /*
 ** This function is called after transitioning from PAGER_UNLOCK to

@@ -43609,15 +44426,17 @@ static int hasHotJournal(Pager *pPager, int *pExists){

     if( rc==SQLITE_OK && !locked ){
       Pgno nPage;                 /* Number of pages in database file */
       /* Check the size of the database file. If it consists of 0 pages,
       ** then delete the journal file. See the header comment above for
       ** the reasoning here.  Delete the obsolete journal file under
       ** a RESERVED lock to avoid race conditions and to avoid violating
       ** [H33020].
       */
       rc = pagerPagecount(pPager, &nPage);
       if( rc==SQLITE_OK ){
         if( nPage==0 ){
         /* If the database is zero pages in size, that means that either (1) the
         ** journal is a remnant from a prior database with the same name where
         ** the database file but not the journal was deleted, or (2) the initial
         ** transaction that populates a new database is being rolled back.
         ** In either case, the journal file can be deleted.  However, take care
         ** not to delete the journal file if it is already open due to
         ** journal_mode=PERSIST.
         */
         if( nPage==0 && !jrnlOpen ){
           sqlite3BeginBenignMalloc();
           if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
             sqlite3OsDelete(pVfs, pPager->zJournal, 0);

@@ -44015,7 +44834,7 @@ SQLITE_PRIVATE int sqlite3PagerAcquire(

       if( rc!=SQLITE_OK ) goto pager_acquire_err;
     }
     if( iFrame==0 && bMmapOk ){
     if( bMmapOk && iFrame==0 ){
       void *pData = 0;
       rc = sqlite3OsFetch(pPager->fd,

@@ -44156,16 +44975,19 @@ SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){

 ** are released, a rollback occurs and the lock on the database is
 ** removed.
 */
 SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){
   if( pPg ){
     Pager *pPager = pPg->pPager;
     if( pPg->flags & PGHDR_MMAP ){
       pagerReleaseMapPage(pPg);
     }else{
       sqlite3PcacheRelease(pPg);
     }
     pagerUnlockIfUnused(pPager);
 SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage *pPg){
   Pager *pPager;
   assert( pPg!=0 );
   pPager = pPg->pPager;
   if( pPg->flags & PGHDR_MMAP ){
     pagerReleaseMapPage(pPg);
   }else{
     sqlite3PcacheRelease(pPg);
   }
   pagerUnlockIfUnused(pPager);
 }
 SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){
   if( pPg ) sqlite3PagerUnrefNotNull(pPg);
 }
 /*

@@ -44220,13 +45042,19 @@ static int pager_open_journal(Pager *pPager){

             (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL):
             (SQLITE_OPEN_MAIN_JOURNAL)
           );
   #ifdef SQLITE_ENABLE_ATOMIC_WRITE
         rc = sqlite3JournalOpen(
             pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
         );
   #else
         rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
   #endif
         /* Verify that the database still has the same name as it did when
         ** it was originally opened. */
         rc = databaseIsUnmoved(pPager);
         if( rc==SQLITE_OK ){
 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
           rc = sqlite3JournalOpen(
               pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
           );
 #else
           rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
 #endif
         }
       }
       assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
     }

@@ -44347,9 +45175,9 @@ SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory

 ** of any open savepoints as appropriate.
 */
 static int pager_write(PgHdr *pPg){
   void *pData = pPg->pData;
   Pager *pPager = pPg->pPager;
   int rc = SQLITE_OK;
   int inJournal;
   /* This routine is not called unless a write-transaction has already
   ** been started. The journal file may or may not be open at this point.

@@ -44360,14 +45188,8 @@ static int pager_write(PgHdr *pPg){

        || pPager->eState==PAGER_WRITER_DBMOD
   );
   assert( assert_pager_state(pPager) );
   /* If an error has been previously detected, report the same error
   ** again. This should not happen, but the check provides robustness. */
   if( NEVER(pPager->errCode) )  return pPager->errCode;
   /* Higher-level routines never call this function if database is not
   ** writable.  But check anyway, just for robustness. */
   if( NEVER(pPager->readOnly) ) return SQLITE_PERM;
   assert( pPager->errCode==0 );
   assert( pPager->readOnly==0 );
   CHECK_PAGE(pPg);

@@ -44391,7 +45213,8 @@ static int pager_write(PgHdr *pPg){

   ** to the journal then we can return right away.
   */
   sqlite3PcacheMakeDirty(pPg);
   if( pageInJournal(pPg) && !subjRequiresPage(pPg) ){
   inJournal = pageInJournal(pPager, pPg);
   if( inJournal && (pPager->nSavepoint==0 || !subjRequiresPage(pPg)) ){
     assert( !pagerUseWal(pPager) );
   }else{

@@ -44399,7 +45222,7 @@ static int pager_write(PgHdr *pPg){

     ** EXCLUSIVE lock on the main database file.  Write the current page to
     ** the transaction journal if it is not there already.
     */
     if( !pageInJournal(pPg) && !pagerUseWal(pPager) ){
     if( !inJournal && !pagerUseWal(pPager) ){
       assert( pagerUseWal(pPager)==0 );
       if( pPg->pgno<=pPager->dbOrigSize && isOpen(pPager->jfd) ){
         u32 cksum;

@@ -44412,7 +45235,7 @@ static int pager_write(PgHdr *pPg){

         assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
         assert( pPager->journalHdr<=pPager->journalOff );
         CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
         CODEC2(pPager, pPg->pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
         cksum = pager_cksum(pPager, (u8*)pData2);
         /* Even if an IO or diskfull error occurs while journalling the

@@ -44464,7 +45287,7 @@ static int pager_write(PgHdr *pPg){

     ** the statement journal format differs from the standard journal format
     ** in that it omits the checksums and the header.
     */
     if( subjRequiresPage(pPg) ){
     if( pPager->nSavepoint>0 && subjRequiresPage(pPg) ){
       rc = subjournalPage(pPg);
     }
   }

@@ -44496,19 +45319,19 @@ SQLITE_PRIVATE int sqlite3PagerWrite(DbPage *pDbPage){

   PgHdr *pPg = pDbPage;
   Pager *pPager = pPg->pPager;
   Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
   assert( (pPg->flags & PGHDR_MMAP)==0 );
   assert( pPager->eState>=PAGER_WRITER_LOCKED );
   assert( pPager->eState!=PAGER_ERROR );
   assert( assert_pager_state(pPager) );
   if( nPagePerSector>1 ){
   if( pPager->sectorSize > (u32)pPager->pageSize ){
     Pgno nPageCount;          /* Total number of pages in database file */
     Pgno pg1;                 /* First page of the sector pPg is located on. */
     int nPage = 0;            /* Number of pages starting at pg1 to journal */
     int ii;                   /* Loop counter */
     int needSync = 0;         /* True if any page has PGHDR_NEED_SYNC */
     Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
     /* Set the doNotSpill NOSYNC bit to 1. This is because we cannot allow
     ** a journal header to be written between the pages journaled by

@@ -44547,14 +45370,14 @@ SQLITE_PRIVATE int sqlite3PagerWrite(DbPage *pDbPage){

             if( pPage->flags&PGHDR_NEED_SYNC ){
               needSync = 1;
             }
             sqlite3PagerUnref(pPage);
             sqlite3PagerUnrefNotNull(pPage);
           }
         }
       }else if( (pPage = pager_lookup(pPager, pg))!=0 ){
         if( pPage->flags&PGHDR_NEED_SYNC ){
           needSync = 1;
         }
         sqlite3PagerUnref(pPage);
         sqlite3PagerUnrefNotNull(pPage);
       }
     }

@@ -44570,7 +45393,7 @@ SQLITE_PRIVATE int sqlite3PagerWrite(DbPage *pDbPage){

         PgHdr *pPage = pager_lookup(pPager, pg1+ii);
         if( pPage ){
           pPage->flags |= PGHDR_NEED_SYNC;
           sqlite3PagerUnref(pPage);
           sqlite3PagerUnrefNotNull(pPage);
         }
       }
     }

@@ -44723,17 +45546,17 @@ static int pager_incr_changecounter(Pager *pPager, int isDirectMode){

 ** If successful, or if called on a pager for which it is a no-op, this
 ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
 */
 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager){
 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zMaster){
   int rc = SQLITE_OK;
   if( !pPager->noSync ){
   if( isOpen(pPager->fd) ){
     void *pArg = (void*)zMaster;
     rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
     if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
   }
   if( rc==SQLITE_OK && !pPager->noSync ){
     assert( !MEMDB );
     rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
   }else if( isOpen(pPager->fd) ){
     assert( !MEMDB );
     rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC_OMITTED, 0);
     if( rc==SQLITE_NOTFOUND ){
       rc = SQLITE_OK;
     }
   }
   return rc;
 }

@@ -44932,7 +45755,7 @@ SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(

       /* Finally, sync the database file. */
       if( !noSync ){
         rc = sqlite3PagerSync(pPager);
         rc = sqlite3PagerSync(pPager, zMaster);
       }
       IOTRACE(("DBSYNC %p\n", pPager))
     }

@@ -45061,7 +45884,9 @@ SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){

   assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
   assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
           || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR );
           || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR
           || rc==SQLITE_CANTOPEN
   );
   /* If an error occurs during a ROLLBACK, we can no longer trust the pager
   ** cache. So call pager_error() on the way out to make any error persistent.

@@ -45464,7 +46289,7 @@ SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, i

   if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
     needSyncPgno = pPg->pgno;
     assert( pPager->journalMode==PAGER_JOURNALMODE_OFF ||
             pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
             pageInJournal(pPager, pPg) || pPg->pgno>pPager->dbOrigSize );
     assert( pPg->flags&PGHDR_DIRTY );
   }

@@ -45498,7 +46323,7 @@ SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, i

   if( MEMDB ){
     assert( pPgOld );
     sqlite3PcacheMove(pPgOld, origPgno);
     sqlite3PagerUnref(pPgOld);
     sqlite3PagerUnrefNotNull(pPgOld);
   }
   if( needSyncPgno ){

@@ -45527,7 +46352,7 @@ SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, i

     }
     pPgHdr->flags |= PGHDR_NEED_SYNC;
     sqlite3PcacheMakeDirty(pPgHdr);
     sqlite3PagerUnref(pPgHdr);
     sqlite3PagerUnrefNotNull(pPgHdr);
   }
   return SQLITE_OK;

@@ -47243,7 +48068,7 @@ SQLITE_PRIVATE int sqlite3WalOpen(

     sqlite3OsClose(pRet->pWalFd);
     sqlite3_free(pRet);
   }else{
     int iDC = sqlite3OsDeviceCharacteristics(pRet->pWalFd);
     int iDC = sqlite3OsDeviceCharacteristics(pDbFd);
     if( iDC & SQLITE_IOCAP_SEQUENTIAL ){ pRet->syncHeader = 0; }
     if( iDC & SQLITE_IOCAP_POWERSAFE_OVERWRITE ){
       pRet->padToSectorBoundary = 0;

@@ -48614,7 +49439,7 @@ static int walWriteToLog(

     iAmt -= iFirstAmt;
     pContent = (void*)(iFirstAmt + (char*)pContent);
     assert( p->syncFlags & (SQLITE_SYNC_NORMAL|SQLITE_SYNC_FULL) );
     rc = sqlite3OsSync(p->pFd, p->syncFlags);
     rc = sqlite3OsSync(p->pFd, p->syncFlags & SQLITE_SYNC_MASK);
     if( iAmt==0 || rc ) return rc;
   }
   rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset);

@@ -49552,7 +50377,6 @@ struct BtCursor {

   Pgno *aOverflow;          /* Cache of overflow page locations */
 #endif
   Pgno pgnoRoot;            /* The root page of this tree */
   sqlite3_int64 cachedRowid; /* Next rowid cache.  0 means not valid */
   CellInfo info;            /* A parse of the cell we are pointing at */
   i64 nKey;        /* Size of pKey, or last integer key */
   void *pKey;      /* Saved key that was cursor's last known position */

@@ -50678,7 +51502,7 @@ static int btreeMoveto(

 ){
   int rc;                    /* Status code */
   UnpackedRecord *pIdxKey;   /* Unpacked index key */
   char aSpace[150];          /* Temp space for pIdxKey - to avoid a malloc */
   char aSpace[200];          /* Temp space for pIdxKey - to avoid a malloc */
   char *pFree = 0;
   if( pKey ){

@@ -50688,6 +51512,10 @@ static int btreeMoveto(

     );
     if( pIdxKey==0 ) return SQLITE_NOMEM;
     sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
     if( pIdxKey->nField==0 ){
       sqlite3DbFree(pCur->pKeyInfo->db, pFree);
       return SQLITE_CORRUPT_BKPT;
     }
   }else{
     pIdxKey = 0;
   }

@@ -51532,13 +52360,12 @@ static void zeroPage(MemPage *pPage, int flags){

     memset(&data[hdr], 0, pBt->usableSize - hdr);
   }
   data[hdr] = (char)flags;
   first = hdr + 8 + 4*((flags&PTF_LEAF)==0 ?1:0);
   first = hdr + ((flags&PTF_LEAF)==0 ? 12 : 8);
   memset(&data[hdr+1], 0, 4);
   data[hdr+7] = 0;
   put2byte(&data[hdr+5], pBt->usableSize);
   pPage->nFree = (u16)(pBt->usableSize - first);
   decodeFlags(pPage, flags);
   pPage->hdrOffset = hdr;
   pPage->cellOffset = first;
   pPage->aDataEnd = &data[pBt->usableSize];
   pPage->aCellIdx = &data[first];

@@ -51642,7 +52469,7 @@ static int getAndInitPage(

     rc = SQLITE_CORRUPT_BKPT;
   }else{
     rc = btreeGetPage(pBt, pgno, ppPage, bReadonly);
     if( rc==SQLITE_OK ){
     if( rc==SQLITE_OK && (*ppPage)->isInit==0 ){
       rc = btreeInitPage(*ppPage);
       if( rc!=SQLITE_OK ){
         releasePage(*ppPage);

@@ -51663,10 +52490,11 @@ static void releasePage(MemPage *pPage){

   if( pPage ){
     assert( pPage->aData );
     assert( pPage->pBt );
     assert( pPage->pDbPage!=0 );
     assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
     assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
     assert( sqlite3_mutex_held(pPage->pBt->mutex) );
     sqlite3PagerUnref(pPage->pDbPage);
     sqlite3PagerUnrefNotNull(pPage->pDbPage);
   }
 }

@@ -53621,7 +54449,6 @@ static int btreeCursor(

   }
   pBt->pCursor = pCur;
   pCur->eState = CURSOR_INVALID;
   pCur->cachedRowid = 0;
   return SQLITE_OK;
 }
 SQLITE_PRIVATE int sqlite3BtreeCursor(

@@ -53663,36 +54490,6 @@ SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor *p){

 }
 /*
 ** Set the cached rowid value of every cursor in the same database file
 ** as pCur and having the same root page number as pCur.  The value is
 ** set to iRowid.
 **
 ** Only positive rowid values are considered valid for this cache.
 ** The cache is initialized to zero, indicating an invalid cache.
 ** A btree will work fine with zero or negative rowids.  We just cannot
 ** cache zero or negative rowids, which means tables that use zero or
 ** negative rowids might run a little slower.  But in practice, zero
 ** or negative rowids are very uncommon so this should not be a problem.
 */
 SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
   BtCursor *p;
   for(p=pCur->pBt->pCursor; p; p=p->pNext){
     if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
   }
   assert( pCur->cachedRowid==iRowid );
 }
 /*
 ** Return the cached rowid for the given cursor.  A negative or zero
 ** return value indicates that the rowid cache is invalid and should be
 ** ignored.  If the rowid cache has never before been set, then a
 ** zero is returned.
 */
 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){
   return pCur->cachedRowid;
 }
 /*
 ** Close a cursor.  The read lock on the database file is released
 ** when the last cursor is closed.
 */

@@ -53743,7 +54540,7 @@ SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){

     int iPage = pCur->iPage;
     memset(&info, 0, sizeof(info));
     btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
     assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
     assert( CORRUPT_DB || memcmp(&info, &pCur->info, sizeof(info))==0 );
   }
 #else
   #define assertCellInfo(x)

@@ -54182,10 +54979,10 @@ SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *p

 /*
 ** Return a pointer to payload information from the entry that the
 ** pCur cursor is pointing to.  The pointer is to the beginning of
 ** the key if skipKey==0 and it points to the beginning of data if
 ** skipKey==1.  The number of bytes of available key/data is written
 ** into *pAmt.  If *pAmt==0, then the value returned will not be
 ** a valid pointer.
 ** the key if index btrees (pPage->intKey==0) and is the data for
 ** table btrees (pPage->intKey==1). The number of bytes of available
 ** key/data is written into *pAmt.  If *pAmt==0, then the value
 ** returned will not be a valid pointer.
 **
 ** This routine is an optimization.  It is common for the entire key
 ** and data to fit on the local page and for there to be no overflow

@@ -54198,41 +54995,21 @@ SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *p

 ** page of the database.  The data might change or move the next time
 ** any btree routine is called.
 */
 static const unsigned char *fetchPayload(
 static const void *fetchPayload(
   BtCursor *pCur,      /* Cursor pointing to entry to read from */
   int *pAmt,           /* Write the number of available bytes here */
   int skipKey          /* read beginning at data if this is true */
   u32 *pAmt            /* Write the number of available bytes here */
 ){
   unsigned char *aPayload;
   MemPage *pPage;
   u32 nKey;
   u32 nLocal;
   assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
   assert( pCur->eState==CURSOR_VALID );
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
   assert( cursorHoldsMutex(pCur) );
   pPage = pCur->apPage[pCur->iPage];
   assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
   if( NEVER(pCur->info.nSize==0) ){
   assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
   if( pCur->info.nSize==0 ){
     btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
                    &pCur->info);
   }
   aPayload = pCur->info.pCell;
   aPayload += pCur->info.nHeader;
   if( pPage->intKey ){
     nKey = 0;
   }else{
     nKey = (int)pCur->info.nKey;
   }
   if( skipKey ){
     aPayload += nKey;
     nLocal = pCur->info.nLocal - nKey;
   }else{
     nLocal = pCur->info.nLocal;
     assert( nLocal<=nKey );
   }
   *pAmt = nLocal;
   return aPayload;
   *pAmt = pCur->info.nLocal;
   return (void*)(pCur->info.pCell + pCur->info.nHeader);
 }

@@ -54250,23 +55027,11 @@ static const unsigned char *fetchPayload(

 ** These routines is used to get quick access to key and data
 ** in the common case where no overflow pages are used.
 */
 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
   const void *p = 0;
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
   assert( cursorHoldsMutex(pCur) );
   if( ALWAYS(pCur->eState==CURSOR_VALID) ){
     p = (const void*)fetchPayload(pCur, pAmt, 0);
   }
   return p;
 SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, u32 *pAmt){
   return fetchPayload(pCur, pAmt);
 }
 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
   const void *p = 0;
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
   assert( cursorHoldsMutex(pCur) );
   if( ALWAYS(pCur->eState==CURSOR_VALID) ){
     p = (const void*)fetchPayload(pCur, pAmt, 1);
   }
   return p;
 SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, u32 *pAmt){
   return fetchPayload(pCur, pAmt);
 }

@@ -54385,8 +55150,6 @@ static void moveToParent(BtCursor *pCur){

 static int moveToRoot(BtCursor *pCur){
   MemPage *pRoot;
   int rc = SQLITE_OK;
   Btree *p = pCur->pBtree;
   BtShared *pBt = p->pBt;
   assert( cursorHoldsMutex(pCur) );
   assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );

@@ -54401,56 +55164,52 @@ static int moveToRoot(BtCursor *pCur){

   }
   if( pCur->iPage>=0 ){
     int i;
     for(i=1; i<=pCur->iPage; i++){
       releasePage(pCur->apPage[i]);
     }
     pCur->iPage = 0;
     while( pCur->iPage ) releasePage(pCur->apPage[pCur->iPage--]);
   }else if( pCur->pgnoRoot==0 ){
     pCur->eState = CURSOR_INVALID;
     return SQLITE_OK;
   }else{
     rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0],
     rc = getAndInitPage(pCur->pBtree->pBt, pCur->pgnoRoot, &pCur->apPage[0],
                         pCur->wrFlag==0 ? PAGER_GET_READONLY : 0);
     if( rc!=SQLITE_OK ){
       pCur->eState = CURSOR_INVALID;
       return rc;
     }
     pCur->iPage = 0;
     /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
     ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
     ** NULL, the caller expects a table b-tree. If this is not the case,
     ** return an SQLITE_CORRUPT error.  */
     assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
     if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
       return SQLITE_CORRUPT_BKPT;
     }
   }
   /* Assert that the root page is of the correct type. This must be the
   ** case as the call to this function that loaded the root-page (either
   ** this call or a previous invocation) would have detected corruption
   ** if the assumption were not true, and it is not possible for the flags
   ** byte to have been modified while this cursor is holding a reference
   ** to the page.  */
   pRoot = pCur->apPage[0];
   assert( pRoot->pgno==pCur->pgnoRoot );
   assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
   /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
   ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
   ** NULL, the caller expects a table b-tree. If this is not the case,
   ** return an SQLITE_CORRUPT error.
   **
   ** Earlier versions of SQLite assumed that this test could not fail
   ** if the root page was already loaded when this function was called (i.e.
   ** if pCur->iPage>=0). But this is not so if the database is corrupted
   ** in such a way that page pRoot is linked into a second b-tree table
   ** (or the freelist).  */
   assert( pRoot->intKey==1 || pRoot->intKey==0 );
   if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
     return SQLITE_CORRUPT_BKPT;
   }
   pCur->aiIdx[0] = 0;
   pCur->info.nSize = 0;
   pCur->atLast = 0;
   pCur->validNKey = 0;
   if( pRoot->nCell==0 && !pRoot->leaf ){
   if( pRoot->nCell>0 ){
     pCur->eState = CURSOR_VALID;
   }else if( !pRoot->leaf ){
     Pgno subpage;
     if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
     subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
     pCur->eState = CURSOR_VALID;
     rc = moveToChild(pCur, subpage);
   }else{
     pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
     pCur->eState = CURSOR_INVALID;
   }
   return rc;
 }

@@ -54606,6 +55365,7 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(

   int *pRes                /* Write search results here */
 ){
   int rc;
   RecordCompare xRecordCompare;
   assert( cursorHoldsMutex(pCur) );
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );

@@ -54627,6 +55387,16 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(

     }
   }
   if( pIdxKey ){
     xRecordCompare = sqlite3VdbeFindCompare(pIdxKey);
     assert( pIdxKey->default_rc==1
          || pIdxKey->default_rc==0
          || pIdxKey->default_rc==-1
     );
   }else{
     xRecordCompare = 0; /* All keys are integers */
   }
   rc = moveToRoot(pCur);
   if( rc ){
     return rc;

@@ -54641,10 +55411,10 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(

   }
   assert( pCur->apPage[0]->intKey || pIdxKey );
   for(;;){
     int lwr, upr, idx;
     int lwr, upr, idx, c;
     Pgno chldPg;
     MemPage *pPage = pCur->apPage[pCur->iPage];
     int c;
     u8 *pCell;                          /* Pointer to current cell in pPage */
     /* pPage->nCell must be greater than zero. If this is the root-page
     ** the cursor would have been INVALID above and this for(;;) loop

@@ -54656,35 +55426,47 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(

     assert( pPage->intKey==(pIdxKey==0) );
     lwr = 0;
     upr = pPage->nCell-1;
     if( biasRight ){
       pCur->aiIdx[pCur->iPage] = (u16)(idx = upr);
     }else{
       pCur->aiIdx[pCur->iPage] = (u16)(idx = (upr+lwr)/2);
     }
     for(;;){
       u8 *pCell;                          /* Pointer to current cell in pPage */
       assert( idx==pCur->aiIdx[pCur->iPage] );
       pCur->info.nSize = 0;
       pCell = findCell(pPage, idx) + pPage->childPtrSize;
       if( pPage->intKey ){
     assert( biasRight==0 || biasRight==1 );
     idx = upr>>(1-biasRight); /* idx = biasRight ? upr : (lwr+upr)/2; */
     pCur->aiIdx[pCur->iPage] = (u16)idx;
     if( xRecordCompare==0 ){
       for(;;){
         i64 nCellKey;
         pCell = findCell(pPage, idx) + pPage->childPtrSize;
         if( pPage->hasData ){
           u32 dummy;
           pCell += getVarint32(pCell, dummy);
           while( 0x80 <= *(pCell++) ){
             if( pCell>=pPage->aDataEnd ) return SQLITE_CORRUPT_BKPT;
           }
         }
         getVarint(pCell, (u64*)&nCellKey);
         if( nCellKey==intKey ){
           c = 0;
         }else if( nCellKey<intKey ){
           c = -1;
         if( nCellKey<intKey ){
           lwr = idx+1;
           if( lwr>upr ){ c = -1; break; }
         }else if( nCellKey>intKey ){
           upr = idx-1;
           if( lwr>upr ){ c = +1; break; }
         }else{
           assert( nCellKey>intKey );
           c = +1;
           assert( nCellKey==intKey );
           pCur->validNKey = 1;
           pCur->info.nKey = nCellKey;
           pCur->aiIdx[pCur->iPage] = (u16)idx;
           if( !pPage->leaf ){
             lwr = idx;
             goto moveto_next_layer;
           }else{
             *pRes = 0;
             rc = SQLITE_OK;
             goto moveto_finish;
           }
         }
         pCur->validNKey = 1;
         pCur->info.nKey = nCellKey;
       }else{
         assert( lwr+upr>=0 );
         idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2; */
       }
     }else{
       for(;;){
         int nCell;
         pCell = findCell(pPage, idx) + pPage->childPtrSize;
         /* The maximum supported page-size is 65536 bytes. This means that
         ** the maximum number of record bytes stored on an index B-Tree
         ** page is less than 16384 bytes and may be stored as a 2-byte

@@ -54693,23 +55475,20 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(

         ** stored entirely within the b-tree page by inspecting the first
         ** 2 bytes of the cell.
         */
         int nCell = pCell[0];
         if( nCell<=pPage->max1bytePayload
          /* && (pCell+nCell)<pPage->aDataEnd */
         ){
         nCell = pCell[0];
         if( nCell<=pPage->max1bytePayload ){
           /* This branch runs if the record-size field of the cell is a
           ** single byte varint and the record fits entirely on the main
           ** b-tree page.  */
           testcase( pCell+nCell+1==pPage->aDataEnd );
           c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
           c = xRecordCompare(nCell, (void*)&pCell[1], pIdxKey, 0);
         }else if( !(pCell[1] & 0x80)
           && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
           /* && (pCell+nCell+2)<=pPage->aDataEnd */
         ){
           /* The record-size field is a 2 byte varint and the record
           ** fits entirely on the main b-tree page.  */
           testcase( pCell+nCell+2==pPage->aDataEnd );
           c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
           c = xRecordCompare(nCell, (void*)&pCell[2], pIdxKey, 0);
         }else{
           /* The record flows over onto one or more overflow pages. In
           ** this case the whole cell needs to be parsed, a buffer allocated

@@ -54724,57 +55503,53 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(

             rc = SQLITE_NOMEM;
             goto moveto_finish;
           }
           pCur->aiIdx[pCur->iPage] = (u16)idx;
           rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
           if( rc ){
             sqlite3_free(pCellKey);
             goto moveto_finish;
           }
           c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
           c = xRecordCompare(nCell, pCellKey, pIdxKey, 0);
           sqlite3_free(pCellKey);
         }
       }
       if( c==0 ){
         if( pPage->intKey && !pPage->leaf ){
           lwr = idx;
           break;
         if( c<0 ){
           lwr = idx+1;
         }else if( c>0 ){
           upr = idx-1;
         }else{
           assert( c==0 );
           *pRes = 0;
           rc = SQLITE_OK;
           pCur->aiIdx[pCur->iPage] = (u16)idx;
           goto moveto_finish;
         }
         if( lwr>upr ) break;
         assert( lwr+upr>=0 );
         idx = (lwr+upr)>>1;  /* idx = (lwr+upr)/2 */
       }
       if( c<0 ){
         lwr = idx+1;
       }else{
         upr = idx-1;
       }
       if( lwr>upr ){
         break;
       }
       pCur->aiIdx[pCur->iPage] = (u16)(idx = (lwr+upr)/2);
     }
     assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
     assert( pPage->isInit );
     if( pPage->leaf ){
       chldPg = 0;
     }else if( lwr>=pPage->nCell ){
       chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
     }else{
       chldPg = get4byte(findCell(pPage, lwr));
     }
     if( chldPg==0 ){
       assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
       pCur->aiIdx[pCur->iPage] = (u16)idx;
       *pRes = c;
       rc = SQLITE_OK;
       goto moveto_finish;
     }
 moveto_next_layer:
     if( lwr>=pPage->nCell ){
       chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
     }else{
       chldPg = get4byte(findCell(pPage, lwr));
     }
     pCur->aiIdx[pCur->iPage] = (u16)lwr;
     pCur->info.nSize = 0;
     pCur->validNKey = 0;
     rc = moveToChild(pCur, chldPg);
     if( rc ) goto moveto_finish;
     if( rc ) break;
   }
 moveto_finish:
   pCur->info.nSize = 0;
   pCur->validNKey = 0;
   return rc;
 }

@@ -54799,6 +55574,15 @@ SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){

 ** successful then set *pRes=0.  If the cursor
 ** was already pointing to the last entry in the database before
 ** this routine was called, then set *pRes=1.
 **
 ** The calling function will set *pRes to 0 or 1.  The initial *pRes value
 ** will be 1 if the cursor being stepped corresponds to an SQL index and
 ** if this routine could have been skipped if that SQL index had been
 ** a unique index.  Otherwise the caller will have set *pRes to zero.
 ** Zero is the common case. The btree implementation is free to use the
 ** initial *pRes value as a hint to improve performance, but the current
 ** SQLite btree implementation does not. (Note that the comdb2 btree
 ** implementation does use this hint, however.)
 */
 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
   int rc;

@@ -54807,6 +55591,7 @@ SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){

   assert( cursorHoldsMutex(pCur) );
   assert( pRes!=0 );
   assert( *pRes==0 || *pRes==1 );
   assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
   if( pCur->eState!=CURSOR_VALID ){
     rc = restoreCursorPosition(pCur);

@@ -54885,6 +55670,15 @@ SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){

 ** successful then set *pRes=0.  If the cursor
 ** was already pointing to the first entry in the database before
 ** this routine was called, then set *pRes=1.
 **
 ** The calling function will set *pRes to 0 or 1.  The initial *pRes value
 ** will be 1 if the cursor being stepped corresponds to an SQL index and
 ** if this routine could have been skipped if that SQL index had been
 ** a unique index.  Otherwise the caller will have set *pRes to zero.
 ** Zero is the common case. The btree implementation is free to use the
 ** initial *pRes value as a hint to improve performance, but the current
 ** SQLite btree implementation does not. (Note that the comdb2 btree
 ** implementation does use this hint, however.)
 */
 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
   int rc;

@@ -54892,6 +55686,7 @@ SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){

   assert( cursorHoldsMutex(pCur) );
   assert( pRes!=0 );
   assert( *pRes==0 || *pRes==1 );
   assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
   pCur->atLast = 0;
   if( pCur->eState!=CURSOR_VALID ){

@@ -55271,6 +56066,7 @@ end_allocate_page:

   if( rc==SQLITE_OK ){
     if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){
       releasePage(*ppPage);
       *ppPage = 0;
       return SQLITE_CORRUPT_BKPT;
     }
     (*ppPage)->isInit = 0;

@@ -55532,7 +56328,7 @@ static int fillInCell(

     nHeader += 4;
   }
   if( pPage->hasData ){
     nHeader += putVarint(&pCell[nHeader], nData+nZero);
     nHeader += putVarint32(&pCell[nHeader], nData+nZero);
   }else{
     nData = nZero = 0;
   }

@@ -55660,7 +56456,6 @@ static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){

   u32 pc;         /* Offset to cell content of cell being deleted */
   u8 *data;       /* pPage->aData */
   u8 *ptr;        /* Used to move bytes around within data[] */
   u8 *endPtr;     /* End of loop */
   int rc;         /* The return code */
   int hdr;        /* Beginning of the header.  0 most pages.  100 page 1 */

@@ -55685,13 +56480,8 @@ static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){

     *pRC = rc;
     return;
   }
   endPtr = &pPage->aCellIdx[2*pPage->nCell - 2];
   assert( (SQLITE_PTR_TO_INT(ptr)&1)==0 );  /* ptr is always 2-byte aligned */
   while( ptr<endPtr ){
     *(u16*)ptr = *(u16*)&ptr[2];
     ptr += 2;
   }
   pPage->nCell--;
   memmove(ptr, ptr+2, 2*(pPage->nCell - idx));
   put2byte(&data[hdr+3], pPage->nCell);
   pPage->nFree += 2;
 }

@@ -55728,9 +56518,6 @@ static void insertCell(

   int ins;          /* Index in data[] where new cell pointer is inserted */
   int cellOffset;   /* Address of first cell pointer in data[] */
   u8 *data;         /* The content of the whole page */
   u8 *ptr;          /* Used for moving information around in data[] */
   u8 *endPtr;       /* End of the loop */
   int nSkip = (iChild ? 4 : 0);
   if( *pRC ) return;

@@ -55781,13 +56568,7 @@ static void insertCell(

     if( iChild ){
       put4byte(&data[idx], iChild);
     }
     ptr = &data[end];
     endPtr = &data[ins];
     assert( (SQLITE_PTR_TO_INT(ptr)&1)==0 );  /* ptr is always 2-byte aligned */
     while( ptr>endPtr ){
       *(u16*)ptr = *(u16*)&ptr[-2];
       ptr -= 2;
     }
     memmove(&data[ins+2], &data[ins], end-ins);
     put2byte(&data[ins], idx);
     put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
 #ifndef SQLITE_OMIT_AUTOVACUUM

@@ -57002,11 +57783,17 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(

   rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
   if( rc ) return rc;
   /* If this is an insert into a table b-tree, invalidate any incrblob
   ** cursors open on the row being replaced (assuming this is a replace
   ** operation - if it is not, the following is a no-op).  */
   if( pCur->pKeyInfo==0 ){
     /* If this is an insert into a table b-tree, invalidate any incrblob
     ** cursors open on the row being replaced */
     invalidateIncrblobCursors(p, nKey, 0);
     /* If the cursor is currently on the last row and we are appending a
     ** new row onto the end, set the "loc" to avoid an unnecessary btreeMoveto()
     ** call */
     if( pCur->validNKey && nKey>0 && pCur->info.nKey==nKey-1 ){
       loc = -1;
     }
   }
   if( !loc ){

@@ -57076,8 +57863,8 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(

   ** row without seeking the cursor. This can be a big performance boost.
   */
   pCur->info.nSize = 0;
   pCur->validNKey = 0;
   if( rc==SQLITE_OK && pPage->nOverflow ){
     pCur->validNKey = 0;
     rc = balance(pCur);
     /* Must make sure nOverflow is reset to zero even if the balance()

@@ -57132,7 +57919,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur){

   ** sub-tree headed by the child page of the cell being deleted. This makes
   ** balancing the tree following the delete operation easier.  */
   if( !pPage->leaf ){
     int notUsed;
     int notUsed = 0;
     rc = sqlite3BtreePrevious(pCur, &notUsed);
     if( rc ) return rc;
   }

@@ -57385,6 +58172,7 @@ static int clearDatabasePage(

   int rc;
   unsigned char *pCell;
   int i;
   int hdr;
   assert( sqlite3_mutex_held(pBt->mutex) );
   if( pgno>btreePagecount(pBt) ){

@@ -57393,6 +58181,7 @@ static int clearDatabasePage(

   rc = getAndInitPage(pBt, pgno, &pPage, 0);
   if( rc ) return rc;
   hdr = pPage->hdrOffset;
   for(i=0; i<pPage->nCell; i++){
     pCell = findCell(pPage, i);
     if( !pPage->leaf ){

@@ -57403,7 +58192,7 @@ static int clearDatabasePage(

     if( rc ) goto cleardatabasepage_out;
   }
   if( !pPage->leaf ){
     rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), 1, pnChange);
     rc = clearDatabasePage(pBt, get4byte(&pPage->aData[hdr+8]), 1, pnChange);
     if( rc ) goto cleardatabasepage_out;
   }else if( pnChange ){
     assert( pPage->intKey );

@@ -57412,7 +58201,7 @@ static int clearDatabasePage(

   if( freePageFlag ){
     freePage(pPage, &rc);
   }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){
     zeroPage(pPage, pPage->aData[0] | PTF_LEAF);
     zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF);
   }
 cleardatabasepage_out:

@@ -57749,7 +58538,7 @@ static void checkAppendMsg(

     sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1);
   }
   if( zMsg1 ){
     sqlite3StrAccumAppend(&pCheck->errMsg, zMsg1, -1);
     sqlite3StrAccumAppendAll(&pCheck->errMsg, zMsg1);
   }
   sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap);
   va_end(ap);

@@ -58613,6 +59402,7 @@ static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){

         rc = SQLITE_ERROR;
       }
       sqlite3DbFree(pErrorDb, pParse->zErrMsg);
       sqlite3ParserReset(pParse);
       sqlite3StackFree(pErrorDb, pParse);
     }
     if( rc ){

@@ -59042,7 +59832,7 @@ SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage){

           /* Sync the database file to disk. */
           if( rc==SQLITE_OK ){
             rc = sqlite3PagerSync(pDestPager);
             rc = sqlite3PagerSync(pDestPager, 0);
           }
         }else{
           sqlite3PagerTruncateImage(pDestPager, nDestTruncate);

@@ -59117,10 +59907,10 @@ SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p){

   /* Set the error code of the destination database handle. */
   rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
   sqlite3Error(p->pDestDb, rc, 0);
   /* Exit the mutexes and free the backup context structure. */
   if( p->pDestDb ){
     sqlite3Error(p->pDestDb, rc, 0);
     /* Exit the mutexes and free the backup context structure. */
     sqlite3LeaveMutexAndCloseZombie(p->pDestDb);
   }
   sqlite3BtreeLeave(p->pSrc);

@@ -59283,6 +60073,42 @@ copy_finished:

 ** name sqlite_value
 */
 #ifdef SQLITE_DEBUG
 /*
 ** Check invariants on a Mem object.
 **
 ** This routine is intended for use inside of assert() statements, like
 ** this:    assert( sqlite3VdbeCheckMemInvariants(pMem) );
 */
 SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){
   /* The MEM_Dyn bit is set if and only if Mem.xDel is a non-NULL destructor
   ** function for Mem.z
   */
   assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 );
   assert( (p->flags & MEM_Dyn)!=0 || p->xDel==0 );
   /* If p holds a string or blob, the Mem.z must point to exactly
   ** one of the following:
   **
   **   (1) Memory in Mem.zMalloc and managed by the Mem object
   **   (2) Memory to be freed using Mem.xDel
   **   (3) An ephermal string or blob
   **   (4) A static string or blob
   */
   if( (p->flags & (MEM_Str|MEM_Blob)) && p->z!=0 ){
     assert(
       ((p->z==p->zMalloc)? 1 : 0) +
       ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
       ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
       ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1
     );
   }
   return 1;
 }
 #endif
 /*
 ** If pMem is an object with a valid string representation, this routine
 ** ensures the internal encoding for the string representation is

@@ -59324,57 +60150,51 @@ SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){

 /*
 ** Make sure pMem->z points to a writable allocation of at least
 ** n bytes.
 **
 ** If the third argument passed to this function is true, then memory
 ** cell pMem must contain a string or blob. In this case the content is
 ** preserved. Otherwise, if the third parameter to this function is false,
 ** any current string or blob value may be discarded.
 **
 ** This function sets the MEM_Dyn flag and clears any xDel callback.
 ** It also clears MEM_Ephem and MEM_Static. If the preserve flag is
 ** not set, Mem.n is zeroed.
 */
 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
   assert( 1 >=
     ((pMem->zMalloc && pMem->zMalloc==pMem->z) ? 1 : 0) +
     (((pMem->flags&MEM_Dyn)&&pMem->xDel) ? 1 : 0) +
     ((pMem->flags&MEM_Ephem) ? 1 : 0) +
     ((pMem->flags&MEM_Static) ? 1 : 0)
   );
 ** min(n,32) bytes.
 **
 ** If the bPreserve argument is true, then copy of the content of
 ** pMem->z into the new allocation.  pMem must be either a string or
 ** blob if bPreserve is true.  If bPreserve is false, any prior content
 ** in pMem->z is discarded.
 */
 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
   assert( sqlite3VdbeCheckMemInvariants(pMem) );
   assert( (pMem->flags&MEM_RowSet)==0 );
   /* If the preserve flag is set to true, then the memory cell must already
   /* If the bPreserve flag is set to true, then the memory cell must already
   ** contain a valid string or blob value.  */
   assert( preserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
   assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
   testcase( bPreserve && pMem->z==0 );
   if( n<32 ) n = 32;
   if( sqlite3DbMallocSize(pMem->db, pMem->zMalloc)<n ){
     if( preserve && pMem->z==pMem->zMalloc ){
   if( pMem->zMalloc==0 || sqlite3DbMallocSize(pMem->db, pMem->zMalloc)<n ){
     if( n<32 ) n = 32;
     if( bPreserve && pMem->z==pMem->zMalloc ){
       pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
       preserve = 0;
       bPreserve = 0;
     }else{
       sqlite3DbFree(pMem->db, pMem->zMalloc);
       pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
     }
     if( pMem->zMalloc==0 ){
       VdbeMemRelease(pMem);
       pMem->z = 0;
       pMem->flags = MEM_Null;
       return SQLITE_NOMEM;
     }
   }
   if( pMem->z && preserve && pMem->zMalloc && pMem->z!=pMem->zMalloc ){
   if( pMem->z && bPreserve && pMem->z!=pMem->zMalloc ){
     memcpy(pMem->zMalloc, pMem->z, pMem->n);
   }
   if( pMem->flags&MEM_Dyn && pMem->xDel ){
     assert( pMem->xDel!=SQLITE_DYNAMIC );
   if( (pMem->flags&MEM_Dyn)!=0 ){
     assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
     pMem->xDel((void *)(pMem->z));
   }
   pMem->z = pMem->zMalloc;
   if( pMem->z==0 ){
     pMem->flags = MEM_Null;
   }else{
     pMem->flags &= ~(MEM_Ephem|MEM_Static);
   }
   pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
   pMem->xDel = 0;
   return (pMem->z ? SQLITE_OK : SQLITE_NOMEM);
   return SQLITE_OK;
 }
 /*

@@ -59541,9 +60361,9 @@ SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p){

     sqlite3VdbeMemFinalize(p, p->u.pDef);
     assert( (p->flags & MEM_Agg)==0 );
     sqlite3VdbeMemRelease(p);
   }else if( p->flags&MEM_Dyn && p->xDel ){
   }else if( p->flags&MEM_Dyn ){
     assert( (p->flags&MEM_RowSet)==0 );
     assert( p->xDel!=SQLITE_DYNAMIC );
     assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
     p->xDel((void *)p->z);
     p->xDel = 0;
   }else if( p->flags&MEM_RowSet ){

@@ -59556,27 +60376,23 @@ SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p){

 /*
 ** Release any memory held by the Mem. This may leave the Mem in an
 ** inconsistent state, for example with (Mem.z==0) and
 ** (Mem.type==SQLITE_TEXT).
 ** (Mem.flags==MEM_Str).
 */
 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
   assert( sqlite3VdbeCheckMemInvariants(p) );
   VdbeMemRelease(p);
   sqlite3DbFree(p->db, p->zMalloc);
   if( p->zMalloc ){
     sqlite3DbFree(p->db, p->zMalloc);
     p->zMalloc = 0;
   }
   p->z = 0;
   p->zMalloc = 0;
   p->xDel = 0;
   assert( p->xDel==0 );  /* Zeroed by VdbeMemRelease() above */
 }
 /*
 ** Convert a 64-bit IEEE double into a 64-bit signed integer.
 ** If the double is too large, return 0x8000000000000000.
 **
 ** Most systems appear to do this simply by assigning
 ** variables and without the extra range tests.  But
 ** there are reports that windows throws an expection
 ** if the floating point value is out of range. (See ticket #2880.)
 ** Because we do not completely understand the problem, we will
 ** take the conservative approach and always do range tests
 ** before attempting the conversion.
 ** If the double is out of range of a 64-bit signed integer then
 ** return the closest available 64-bit signed integer.
 */
 static i64 doubleToInt64(double r){
 #ifdef SQLITE_OMIT_FLOATING_POINT

@@ -59593,14 +60409,10 @@ static i64 doubleToInt64(double r){

   static const i64 maxInt = LARGEST_INT64;
   static const i64 minInt = SMALLEST_INT64;
   if( r<(double)minInt ){
     return minInt;
   }else if( r>(double)maxInt ){
     /* minInt is correct here - not maxInt.  It turns out that assigning
     ** a very large positive number to an integer results in a very large
     ** negative integer.  This makes no sense, but it is what x86 hardware
     ** does so for compatibility we will do the same in software. */
   if( r<=(double)minInt ){
     return minInt;
   }else if( r>=(double)maxInt ){
     return maxInt;
   }else{
     return (i64)r;
   }

@@ -59682,17 +60494,11 @@ SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){

   **
   ** The second and third terms in the following conditional enforces
   ** the second condition under the assumption that addition overflow causes
   ** values to wrap around.  On x86 hardware, the third term is always
   ** true and could be omitted.  But we leave it in because other
   ** architectures might behave differently.
   ** values to wrap around.
   */
   if( pMem->r==(double)pMem->u.i
    && pMem->u.i>SMALLEST_INT64
 #if defined(__i486__) || defined(__x86_64__)
    && ALWAYS(pMem->u.i<LARGEST_INT64)
 #else
    && pMem->u.i<LARGEST_INT64
 #endif
   ){
     pMem->flags |= MEM_Int;
   }

@@ -59762,7 +60568,9 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){

     sqlite3RowSetClear(pMem->u.pRowSet);
   }
   MemSetTypeFlag(pMem, MEM_Null);
   pMem->type = SQLITE_NULL;
 }
 SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value *p){
   sqlite3VdbeMemSetNull((Mem*)p);
 }
 /*

@@ -59772,7 +60580,6 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){

 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
   sqlite3VdbeMemRelease(pMem);
   pMem->flags = MEM_Blob|MEM_Zero;
   pMem->type = SQLITE_BLOB;
   pMem->n = 0;
   if( n<0 ) n = 0;
   pMem->u.nZero = n;

@@ -59795,7 +60602,6 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){

   sqlite3VdbeMemRelease(pMem);
   pMem->u.i = val;
   pMem->flags = MEM_Int;
   pMem->type = SQLITE_INTEGER;
 }
 #ifndef SQLITE_OMIT_FLOATING_POINT

@@ -59810,7 +60616,6 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){

     sqlite3VdbeMemRelease(pMem);
     pMem->r = val;
     pMem->flags = MEM_Real;
     pMem->type = SQLITE_FLOAT;
   }
 }
 #endif

@@ -59866,7 +60671,7 @@ SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){

   Mem *pX;
   for(i=1, pX=&pVdbe->aMem[1]; i<=pVdbe->nMem; i++, pX++){
     if( pX->pScopyFrom==pMem ){
       pX->flags |= MEM_Invalid;
       pX->flags |= MEM_Undefined;
       pX->pScopyFrom = 0;
     }
   }

@@ -59877,7 +60682,7 @@ SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){

 /*
 ** Size of struct Mem not including the Mem.zMalloc member.
 */
 #define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
 #define MEMCELLSIZE offsetof(Mem,zMalloc)
 /*
 ** Make an shallow copy of pFrom into pTo.  Prior contents of

@@ -59908,6 +60713,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){

   VdbeMemRelease(pTo);
   memcpy(pTo, pFrom, MEMCELLSIZE);
   pTo->flags &= ~MEM_Dyn;
   pTo->xDel = 0;
   if( pTo->flags&(MEM_Str|MEM_Blob) ){
     if( 0==(pFrom->flags&MEM_Static) ){

@@ -60018,7 +60824,6 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr(

   pMem->n = nByte;
   pMem->flags = flags;
   pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
   pMem->type = (enc==0 ? SQLITE_BLOB : SQLITE_TEXT);
 #ifndef SQLITE_OMIT_UTF16
   if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){

@@ -60034,119 +60839,6 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr(

 }
 /*
 ** Compare the values contained by the two memory cells, returning
 ** negative, zero or positive if pMem1 is less than, equal to, or greater
 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
 ** and reals) sorted numerically, followed by text ordered by the collating
 ** sequence pColl and finally blob's ordered by memcmp().
 **
 ** Two NULL values are considered equal by this function.
 */
 SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
   int rc;
   int f1, f2;
   int combined_flags;
   f1 = pMem1->flags;
   f2 = pMem2->flags;
   combined_flags = f1|f2;
   assert( (combined_flags & MEM_RowSet)==0 );
   /* If one value is NULL, it is less than the other. If both values
   ** are NULL, return 0.
   */
   if( combined_flags&MEM_Null ){
     return (f2&MEM_Null) - (f1&MEM_Null);
   }
   /* If one value is a number and the other is not, the number is less.
   ** If both are numbers, compare as reals if one is a real, or as integers
   ** if both values are integers.
   */
   if( combined_flags&(MEM_Int|MEM_Real) ){
     double r1, r2;
     if( (f1 & f2 & MEM_Int)!=0 ){
       if( pMem1->u.i < pMem2->u.i ) return -1;
       if( pMem1->u.i > pMem2->u.i ) return 1;
       return 0;
     }
     if( (f1&MEM_Real)!=0 ){
       r1 = pMem1->r;
     }else if( (f1&MEM_Int)!=0 ){
       r1 = (double)pMem1->u.i;
     }else{
       return 1;
     }
     if( (f2&MEM_Real)!=0 ){
       r2 = pMem2->r;
     }else if( (f2&MEM_Int)!=0 ){
       r2 = (double)pMem2->u.i;
     }else{
       return -1;
     }
     if( r1<r2 ) return -1;
     if( r1>r2 ) return 1;
     return 0;
   }
   /* If one value is a string and the other is a blob, the string is less.
   ** If both are strings, compare using the collating functions.
   */
   if( combined_flags&MEM_Str ){
     if( (f1 & MEM_Str)==0 ){
       return 1;
     }
     if( (f2 & MEM_Str)==0 ){
       return -1;
     }
     assert( pMem1->enc==pMem2->enc );
     assert( pMem1->enc==SQLITE_UTF8 ||
             pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
     /* The collation sequence must be defined at this point, even if
     ** the user deletes the collation sequence after the vdbe program is
     ** compiled (this was not always the case).
     */
     assert( !pColl || pColl->xCmp );
     if( pColl ){
       if( pMem1->enc==pColl->enc ){
         /* The strings are already in the correct encoding.  Call the
         ** comparison function directly */
         return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
       }else{
         const void *v1, *v2;
         int n1, n2;
         Mem c1;
         Mem c2;
         memset(&c1, 0, sizeof(c1));
         memset(&c2, 0, sizeof(c2));
         sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
         sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
         v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
         n1 = v1==0 ? 0 : c1.n;
         v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
         n2 = v2==0 ? 0 : c2.n;
         rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
         sqlite3VdbeMemRelease(&c1);
         sqlite3VdbeMemRelease(&c2);
         return rc;
       }
     }
     /* If a NULL pointer was passed as the collate function, fall through
     ** to the blob case and use memcmp().  */
   }
   /* Both values must be blobs.  Compare using memcmp().  */
   rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n);
   if( rc==0 ){
     rc = pMem1->n - pMem2->n;
   }
   return rc;
 }
 /*
 ** Move data out of a btree key or data field and into a Mem structure.
 ** The data or key is taken from the entry that pCur is currently pointing
 ** to.  offset and amt determine what portion of the data or key to retrieve.

@@ -60161,13 +60853,13 @@ SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const C

 */
 SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(
   BtCursor *pCur,   /* Cursor pointing at record to retrieve. */
   int offset,       /* Offset from the start of data to return bytes from. */
   int amt,          /* Number of bytes to return. */
   u32 offset,       /* Offset from the start of data to return bytes from. */
   u32 amt,          /* Number of bytes to return. */
   int key,          /* If true, retrieve from the btree key, not data. */
   Mem *pMem         /* OUT: Return data in this Mem structure. */
 ){
   char *zData;        /* Data from the btree layer */
   int available = 0;  /* Number of bytes available on the local btree page */
   u32 available = 0;  /* Number of bytes available on the local btree page */
   int rc = SQLITE_OK; /* Return code */
   assert( sqlite3BtreeCursorIsValid(pCur) );

@@ -60182,26 +60874,26 @@ SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(

   }
   assert( zData!=0 );
   if( offset+amt<=available && (pMem->flags&MEM_Dyn)==0 ){
   if( offset+amt<=available ){
     sqlite3VdbeMemRelease(pMem);
     pMem->z = &zData[offset];
     pMem->flags = MEM_Blob|MEM_Ephem;
     pMem->n = (int)amt;
   }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
     pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
     pMem->enc = 0;
     pMem->type = SQLITE_BLOB;
     if( key ){
       rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
     }else{
       rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
     }
     pMem->z[amt] = 0;
     pMem->z[amt+1] = 0;
     if( rc!=SQLITE_OK ){
     if( rc==SQLITE_OK ){
       pMem->z[amt] = 0;
       pMem->z[amt+1] = 0;
       pMem->flags = MEM_Blob|MEM_Term;
       pMem->n = (int)amt;
     }else{
       sqlite3VdbeMemRelease(pMem);
     }
   }
   pMem->n = amt;
   return rc;
 }

@@ -60259,7 +60951,6 @@ SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *db){

   Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
   if( p ){
     p->flags = MEM_Null;
     p->type = SQLITE_NULL;
     p->db = db;
   }
   return p;

@@ -60296,20 +60987,18 @@ static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){

       Index *pIdx = p->pIdx;      /* Index being probed */
       int nByte;                  /* Bytes of space to allocate */
       int i;                      /* Counter variable */
       int nCol = pIdx->nColumn+1; /* Number of index columns including rowid */
       int nCol = pIdx->nColumn;   /* Number of index columns including rowid */
       nByte = sizeof(Mem) * nCol + sizeof(UnpackedRecord);
       nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
       pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte);
       if( pRec ){
         pRec->pKeyInfo = sqlite3IndexKeyinfo(p->pParse, pIdx);
         pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
         if( pRec->pKeyInfo ){
           assert( pRec->pKeyInfo->nField+1==nCol );
           pRec->pKeyInfo->enc = ENC(db);
           pRec->flags = UNPACKED_PREFIX_MATCH;
           pRec->aMem = (Mem *)&pRec[1];
           assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
           assert( pRec->pKeyInfo->enc==ENC(db) );
           pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord)));
           for(i=0; i<nCol; i++){
             pRec->aMem[i].flags = MEM_Null;
             pRec->aMem[i].type = SQLITE_NULL;
             pRec->aMem[i].db = db;
           }
         }else{

@@ -60360,16 +61049,7 @@ static int valueFromExpr(

     return SQLITE_OK;
   }
   op = pExpr->op;
   /* op can only be TK_REGISTER if we have compiled with SQLITE_ENABLE_STAT4.
   ** The ifdef here is to enable us to achieve 100% branch test coverage even
   ** when SQLITE_ENABLE_STAT4 is omitted.
   */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   if( op==TK_REGISTER ) op = pExpr->op2;
 #else
   if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
 #endif
   /* Handle negative integers in a single step.  This is needed in the
   ** case when the value is -9223372036854775808.

@@ -60391,7 +61071,6 @@ static int valueFromExpr(

       zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
       if( zVal==0 ) goto no_mem;
       sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
       if( op==TK_FLOAT ) pVal->type = SQLITE_FLOAT;
     }
     if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
       sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);

@@ -60409,9 +61088,9 @@ static int valueFromExpr(

     ){
       sqlite3VdbeMemNumerify(pVal);
       if( pVal->u.i==SMALLEST_INT64 ){
         pVal->flags &= MEM_Int;
         pVal->flags &= ~MEM_Int;
         pVal->flags |= MEM_Real;
         pVal->r = (double)LARGEST_INT64;
         pVal->r = (double)SMALLEST_INT64;
       }else{
         pVal->u.i = -pVal->u.i;
       }

@@ -60437,9 +61116,6 @@ static int valueFromExpr(

   }
 #endif
   if( pVal ){
     sqlite3VdbeMemStoreType(pVal);
   }
   *ppVal = pVal;
   return rc;

@@ -60510,7 +61186,7 @@ static void recordFunc(

   }else{
     aRet[0] = nSerial+1;
     sqlite3PutVarint(&aRet[1], iSerial);
     sqlite3VdbeSerialPut(&aRet[1+nSerial], nVal, argv[0], file_format);
     sqlite3VdbeSerialPut(&aRet[1+nSerial], argv[0], iSerial);
     sqlite3_result_blob(context, aRet, nRet, SQLITE_TRANSIENT);
     sqlite3DbFree(db, aRet);
   }

@@ -60588,10 +61264,9 @@ SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue(

     pVal = valueNew(db, &alloc);
     if( pVal ){
       sqlite3VdbeMemSetNull((Mem*)pVal);
       *pbOk = 1;
     }
   }else if( pExpr->op==TK_VARIABLE
         || (pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE)
         || NEVER(pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE)
   ){
     Vdbe *v;
     int iBindVar = pExpr->iColumn;

@@ -60604,16 +61279,12 @@ SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue(

           sqlite3ValueApplyAffinity(pVal, affinity, ENC(db));
         }
         pVal->db = pParse->db;
         *pbOk = 1;
         sqlite3VdbeMemStoreType((Mem*)pVal);
       }
     }else{
       *pbOk = 0;
     }
   }else{
     rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, &alloc);
     *pbOk = (pVal!=0);
   }
   *pbOk = (pVal!=0);
   assert( pVal==0 || pVal->db==db );
   return rc;

@@ -60627,13 +61298,13 @@ SQLITE_PRIVATE int sqlite3Stat4ProbeSetValue(

 SQLITE_PRIVATE void sqlite3Stat4ProbeFree(UnpackedRecord *pRec){
   if( pRec ){
     int i;
     int nCol = pRec->pKeyInfo->nField+1;
     int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField;
     Mem *aMem = pRec->aMem;
     sqlite3 *db = aMem[0].db;
     for(i=0; i<nCol; i++){
       sqlite3DbFree(db, aMem[i].zMalloc);
     }
     sqlite3DbFree(db, pRec->pKeyInfo);
     sqlite3KeyInfoUnref(pRec->pKeyInfo);
     sqlite3DbFree(db, pRec);
   }
 }

@@ -60699,7 +61370,8 @@ SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){

 /*
 ** Create a new virtual database engine.
 */
 SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3 *db){
 SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){
   sqlite3 *db = pParse->db;
   Vdbe *p;
   p = sqlite3DbMallocZero(db, sizeof(Vdbe) );
   if( p==0 ) return 0;

@@ -60711,6 +61383,10 @@ SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3 *db){

   p->pPrev = 0;
   db->pVdbe = p;
   p->magic = VDBE_MAGIC_INIT;
   p->pParse = pParse;
   assert( pParse->aLabel==0 );
   assert( pParse->nLabel==0 );
   assert( pParse->nOpAlloc==0 );
   return p;
 }

@@ -60757,15 +61433,6 @@ SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){

   pB->isPrepareV2 = pA->isPrepareV2;
 }
 #ifdef SQLITE_DEBUG
 /*
 ** Turn tracing on or off
 */
 SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe *p, FILE *trace){
   p->trace = trace;
 }
 #endif
 /*
 ** Resize the Vdbe.aOp array so that it is at least one op larger than
 ** it was.

@@ -60775,17 +61442,29 @@ SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe *p, FILE *trace){

 ** unchanged (this is so that any opcodes already allocated can be
 ** correctly deallocated along with the rest of the Vdbe).
 */
 static int growOpArray(Vdbe *p){
 static int growOpArray(Vdbe *v){
   VdbeOp *pNew;
   Parse *p = v->pParse;
   int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op)));
   pNew = sqlite3DbRealloc(p->db, p->aOp, nNew*sizeof(Op));
   pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
   if( pNew ){
     p->nOpAlloc = sqlite3DbMallocSize(p->db, pNew)/sizeof(Op);
     p->aOp = pNew;
     v->aOp = pNew;
   }
   return (pNew ? SQLITE_OK : SQLITE_NOMEM);
 }
 #ifdef SQLITE_DEBUG
 /* This routine is just a convenient place to set a breakpoint that will
 ** fire after each opcode is inserted and displayed using
 ** "PRAGMA vdbe_addoptrace=on".
 */
 static void test_addop_breakpoint(void){
   static int n = 0;
   n++;
 }
 #endif
 /*
 ** Add a new instruction to the list of instructions current in the
 ** VDBE.  Return the address of the new instruction.

@@ -60809,7 +61488,7 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){

   i = p->nOp;
   assert( p->magic==VDBE_MAGIC_INIT );
   assert( op>0 && op<0xff );
   if( p->nOpAlloc<=i ){
   if( p->pParse->nOpAlloc<=i ){
     if( growOpArray(p) ){
       return 1;
     }

@@ -60823,16 +61502,31 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){

   pOp->p3 = p3;
   pOp->p4.p = 0;
   pOp->p4type = P4_NOTUSED;
 #ifdef SQLITE_DEBUG
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
   pOp->zComment = 0;
 #endif
 #ifdef SQLITE_DEBUG
   if( p->db->flags & SQLITE_VdbeAddopTrace ){
     int jj, kk;
     Parse *pParse = p->pParse;
     for(jj=kk=0; jj<SQLITE_N_COLCACHE; jj++){
       struct yColCache *x = pParse->aColCache + jj;
       if( x->iLevel>pParse->iCacheLevel || x->iReg==0 ) continue;
       printf(" r[%d]={%d:%d}", x->iReg, x->iTable, x->iColumn);
       kk++;
     }
     if( kk ) printf("\n");
     sqlite3VdbePrintOp(0, i, &p->aOp[i]);
     test_addop_breakpoint();
   }
 #endif
 #ifdef VDBE_PROFILE
   pOp->cycles = 0;
   pOp->cnt = 0;
 #endif
 #ifdef SQLITE_VDBE_COVERAGE
   pOp->iSrcLine = 0;
 #endif
   return i;
 }
 SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){

@@ -60908,9 +61602,10 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(

 **
 ** Zero is returned if a malloc() fails.
 */
 SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe *p){
 SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe *v){
   Parse *p = v->pParse;
   int i = p->nLabel++;
   assert( p->magic==VDBE_MAGIC_INIT );
   assert( v->magic==VDBE_MAGIC_INIT );
   if( (i & (i-1))==0 ){
     p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
                                        (i*2+1)*sizeof(p->aLabel[0]));

@@ -60926,13 +61621,15 @@ SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe *p){

 ** be inserted.  The parameter "x" must have been obtained from
 ** a prior call to sqlite3VdbeMakeLabel().
 */
 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *p, int x){
 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *v, int x){
   Parse *p = v->pParse;
   int j = -1-x;
   assert( p->magic==VDBE_MAGIC_INIT );
   assert( v->magic==VDBE_MAGIC_INIT );
   assert( j<p->nLabel );
   if( j>=0 && p->aLabel ){
     p->aLabel[j] = p->nOp;
     p->aLabel[j] = v->nOp;
   }
   p->iFixedOp = v->nOp - 1;
 }
 /*

@@ -61080,7 +61777,8 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){

   int i;
   int nMaxArgs = *pMaxFuncArgs;
   Op *pOp;
   int *aLabel = p->aLabel;
   Parse *pParse = p->pParse;
   int *aLabel = pParse->aLabel;
   p->readOnly = 1;
   p->bIsReader = 0;
   for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){

@@ -61127,12 +61825,14 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){

       }
 #endif
       case OP_Next:
       case OP_NextIfOpen:
       case OP_SorterNext: {
         pOp->p4.xAdvance = sqlite3BtreeNext;
         pOp->p4type = P4_ADVANCE;
         break;
       }
       case OP_Prev: {
       case OP_Prev:
       case OP_PrevIfOpen: {
         pOp->p4.xAdvance = sqlite3BtreePrevious;
         pOp->p4type = P4_ADVANCE;
         break;

@@ -61141,12 +61841,13 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){

     pOp->opflags = sqlite3OpcodeProperty[opcode];
     if( (pOp->opflags & OPFLG_JUMP)!=0 && pOp->p2<0 ){
       assert( -1-pOp->p2<p->nLabel );
       assert( -1-pOp->p2<pParse->nLabel );
       pOp->p2 = aLabel[-1-pOp->p2];
     }
   }
   sqlite3DbFree(p->db, p->aLabel);
   p->aLabel = 0;
   sqlite3DbFree(p->db, pParse->aLabel);
   pParse->aLabel = 0;
   pParse->nLabel = 0;
   *pMaxFuncArgs = nMaxArgs;
   assert( p->bIsReader!=0 || p->btreeMask==0 );
 }

@@ -61187,10 +61888,10 @@ SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg)

 ** Add a whole list of operations to the operation stack.  Return the
 ** address of the first operation added.
 */
 SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){
 SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp, int iLineno){
   int addr;
   assert( p->magic==VDBE_MAGIC_INIT );
   if( p->nOp + nOp > p->nOpAlloc && growOpArray(p) ){
   if( p->nOp + nOp > p->pParse->nOpAlloc && growOpArray(p) ){
     return 0;
   }
   addr = p->nOp;

@@ -61202,7 +61903,8 @@ SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp)

       VdbeOp *pOut = &p->aOp[i+addr];
       pOut->opcode = pIn->opcode;
       pOut->p1 = pIn->p1;
       if( p2<0 && (sqlite3OpcodeProperty[pOut->opcode] & OPFLG_JUMP)!=0 ){
       if( p2<0 ){
         assert( sqlite3OpcodeProperty[pOut->opcode] & OPFLG_JUMP );
         pOut->p2 = addr + ADDR(p2);
       }else{
         pOut->p2 = p2;

@@ -61211,8 +61913,15 @@ SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp)

       pOut->p4type = P4_NOTUSED;
       pOut->p4.p = 0;
       pOut->p5 = 0;
 #ifdef SQLITE_DEBUG
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
       pOut->zComment = 0;
 #endif
 #ifdef SQLITE_VDBE_COVERAGE
       pOut->iSrcLine = iLineno+i;
 #else
       (void)iLineno;
 #endif
 #ifdef SQLITE_DEBUG
       if( p->db->flags & SQLITE_VdbeAddopTrace ){
         sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]);
       }

@@ -61274,7 +61983,8 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 val){

 ** the address of the next instruction to be coded.
 */
 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe *p, int addr){
   if( ALWAYS(addr>=0) ) sqlite3VdbeChangeP2(p, addr, p->nOp);
   sqlite3VdbeChangeP2(p, addr, p->nOp);
   p->pParse->iFixedOp = p->nOp - 1;
 }

@@ -61300,12 +62010,14 @@ static void freeP4(sqlite3 *db, int p4type, void *p4){

       case P4_REAL:
       case P4_INT64:
       case P4_DYNAMIC:
       case P4_KEYINFO:
       case P4_INTARRAY:
       case P4_KEYINFO_HANDOFF: {
       case P4_INTARRAY: {
         sqlite3DbFree(db, p4);
         break;
       }
       case P4_KEYINFO: {
         if( db->pnBytesFreed==0 ) sqlite3KeyInfoUnref((KeyInfo*)p4);
         break;
       }
       case P4_MPRINTF: {
         if( db->pnBytesFreed==0 ) sqlite3_free(p4);
         break;

@@ -61342,7 +62054,7 @@ static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){

     Op *pOp;
     for(pOp=aOp; pOp<&aOp[nOp]; pOp++){
       freeP4(db, pOp->p4type, pOp->p4.p);
 #ifdef SQLITE_DEBUG
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
       sqlite3DbFree(db, pOp->zComment);
 #endif
     }

@@ -61370,6 +62082,19 @@ SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){

     freeP4(db, pOp->p4type, pOp->p4.p);
     memset(pOp, 0, sizeof(pOp[0]));
     pOp->opcode = OP_Noop;
     if( addr==p->nOp-1 ) p->nOp--;
   }
 }
 /*
 ** Remove the last opcode inserted
 */
 SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){
   if( (p->nOp-1)>(p->pParse->iFixedOp) && p->aOp[p->nOp-1].opcode==op ){
     sqlite3VdbeChangeToNoop(p, p->nOp-1);
     return 1;
   }else{
     return 0;
   }
 }

@@ -61383,14 +62108,6 @@ SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){

 ** the string is made into memory obtained from sqlite3_malloc().
 ** A value of n==0 means copy bytes of zP4 up to and including the
 ** first null byte.  If n>0 then copy n+1 bytes of zP4.
 **
 ** If n==P4_KEYINFO it means that zP4 is a pointer to a KeyInfo structure.
 ** A copy is made of the KeyInfo structure into memory obtained from
 ** sqlite3_malloc, to be freed when the Vdbe is finalized.
 ** n==P4_KEYINFO_HANDOFF indicates that zP4 points to a KeyInfo structure
 ** stored in memory that the caller has obtained from sqlite3_malloc. The
 ** caller should not free the allocation, it will be freed when the Vdbe is
 ** finalized.
 **
 ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
 ** to a string or structure that is guaranteed to exist for the lifetime of

@@ -61405,7 +62122,7 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int

   db = p->db;
   assert( p->magic==VDBE_MAGIC_INIT );
   if( p->aOp==0 || db->mallocFailed ){
     if ( n!=P4_KEYINFO && n!=P4_VTAB ) {
     if( n!=P4_VTAB ){
       freeP4(db, n, (void*)*(char**)&zP4);
     }
     return;

@@ -61428,19 +62145,6 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int

     pOp->p4.p = 0;
     pOp->p4type = P4_NOTUSED;
   }else if( n==P4_KEYINFO ){
     KeyInfo *pOrig, *pNew;
     pOrig = (KeyInfo*)zP4;
     pOp->p4.pKeyInfo = pNew = sqlite3KeyInfoAlloc(db, pOrig->nField);
     if( pNew ){
       memcpy(pNew->aColl, pOrig->aColl, pOrig->nField*sizeof(pNew->aColl[0]));
       memcpy(pNew->aSortOrder, pOrig->aSortOrder, pOrig->nField);
       pOp->p4type = P4_KEYINFO;
     }else{
       p->db->mallocFailed = 1;
       pOp->p4type = P4_NOTUSED;
     }
   }else if( n==P4_KEYINFO_HANDOFF ){
     pOp->p4.p = (void*)zP4;
     pOp->p4type = P4_KEYINFO;
   }else if( n==P4_VTAB ){

@@ -61458,7 +62162,19 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int

   }
 }
 #ifndef NDEBUG
 /*
 ** Set the P4 on the most recently added opcode to the KeyInfo for the
 ** index given.
 */
 SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){
   Vdbe *v = pParse->pVdbe;
   assert( v!=0 );
   assert( pIdx!=0 );
   sqlite3VdbeChangeP4(v, -1, (char*)sqlite3KeyInfoOfIndex(pParse, pIdx),
                       P4_KEYINFO);
 }
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
 /*
 ** Change the comment on the most recently coded instruction.  Or
 ** insert a No-op and add the comment to that new instruction.  This

@@ -61493,6 +62209,15 @@ SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){

 }
 #endif  /* NDEBUG */
 #ifdef SQLITE_VDBE_COVERAGE
 /*
 ** Set the value if the iSrcLine field for the previously coded instruction.
 */
 SQLITE_PRIVATE void sqlite3VdbeSetLineNumber(Vdbe *v, int iLine){
   sqlite3VdbeGetOp(v,-1)->iSrcLine = iLine;
 }
 #endif /* SQLITE_VDBE_COVERAGE */
 /*
 ** Return the opcode for a given address.  If the address is -1, then
 ** return the most recently inserted opcode.

@@ -61505,14 +62230,6 @@ SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){

 ** this routine is a valid pointer.  But because the dummy.opcode is 0,
 ** dummy will never be written to.  This is verified by code inspection and
 ** by running with Valgrind.
 **
 ** About the #ifdef SQLITE_OMIT_TRACE:  Normally, this routine is never called
 ** unless p->nOp>0.  This is because in the absense of SQLITE_OMIT_TRACE,
 ** an OP_Trace instruction is always inserted by sqlite3VdbeGet() as soon as
 ** a new VDBE is created.  So we are free to set addr to p->nOp-1 without
 ** having to double-check to make sure that the result is non-negative. But
 ** if SQLITE_OMIT_TRACE is defined, the OP_Trace is omitted and we do need to
 ** check the value of p->nOp-1 before continuing.
 */
 SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
   /* C89 specifies that the constant "dummy" will be initialized to all

@@ -61520,9 +62237,6 @@ SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){

   static VdbeOp dummy;  /* Ignore the MSVC warning about no initializer */
   assert( p->magic==VDBE_MAGIC_INIT );
   if( addr<0 ){
 #ifdef SQLITE_OMIT_TRACE
     if( p->nOp==0 ) return (VdbeOp*)&dummy;
 #endif
     addr = p->nOp - 1;
   }
   assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );

@@ -61533,6 +62247,97 @@ SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){

   }
 }
 #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS)
 /*
 ** Return an integer value for one of the parameters to the opcode pOp
 ** determined by character c.
 */
 static int translateP(char c, const Op *pOp){
   if( c=='1' ) return pOp->p1;
   if( c=='2' ) return pOp->p2;
   if( c=='3' ) return pOp->p3;
   if( c=='4' ) return pOp->p4.i;
   return pOp->p5;
 }
 /*
 ** Compute a string for the "comment" field of a VDBE opcode listing.
 **
 ** The Synopsis: field in comments in the vdbe.c source file gets converted
 ** to an extra string that is appended to the sqlite3OpcodeName().  In the
 ** absence of other comments, this synopsis becomes the comment on the opcode.
 ** Some translation occurs:
 **
 **       "PX"      ->  "r[X]"
 **       "PX@PY"   ->  "r[X..X+Y-1]"  or "r[x]" if y is 0 or 1
 **       "PX@PY+1" ->  "r[X..X+Y]"    or "r[x]" if y is 0
 **       "PY..PY"  ->  "r[X..Y]"      or "r[x]" if y<=x
 */
 static int displayComment(
   const Op *pOp,     /* The opcode to be commented */
   const char *zP4,   /* Previously obtained value for P4 */
   char *zTemp,       /* Write result here */
   int nTemp          /* Space available in zTemp[] */
 ){
   const char *zOpName;
   const char *zSynopsis;
   int nOpName;
   int ii, jj;
   zOpName = sqlite3OpcodeName(pOp->opcode);
   nOpName = sqlite3Strlen30(zOpName);
   if( zOpName[nOpName+1] ){
     int seenCom = 0;
     char c;
     zSynopsis = zOpName += nOpName + 1;
     for(ii=jj=0; jj<nTemp-1 && (c = zSynopsis[ii])!=0; ii++){
       if( c=='P' ){
         c = zSynopsis[++ii];
         if( c=='4' ){
           sqlite3_snprintf(nTemp-jj, zTemp+jj, "%s", zP4);
         }else if( c=='X' ){
           sqlite3_snprintf(nTemp-jj, zTemp+jj, "%s", pOp->zComment);
           seenCom = 1;
         }else{
           int v1 = translateP(c, pOp);
           int v2;
           sqlite3_snprintf(nTemp-jj, zTemp+jj, "%d", v1);
           if( strncmp(zSynopsis+ii+1, "@P", 2)==0 ){
             ii += 3;
             jj += sqlite3Strlen30(zTemp+jj);
             v2 = translateP(zSynopsis[ii], pOp);
             if( strncmp(zSynopsis+ii+1,"+1",2)==0 ){
               ii += 2;
               v2++;
             }
             if( v2>1 ){
               sqlite3_snprintf(nTemp-jj, zTemp+jj, "..%d", v1+v2-1);
             }
           }else if( strncmp(zSynopsis+ii+1, "..P3", 4)==0 && pOp->p3==0 ){
             ii += 4;
           }
         }
         jj += sqlite3Strlen30(zTemp+jj);
       }else{
         zTemp[jj++] = c;
       }
     }
     if( !seenCom && jj<nTemp-5 && pOp->zComment ){
       sqlite3_snprintf(nTemp-jj, zTemp+jj, "; %s", pOp->zComment);
       jj += sqlite3Strlen30(zTemp+jj);
     }
     if( jj<nTemp ) zTemp[jj] = 0;
   }else if( pOp->zComment ){
     sqlite3_snprintf(nTemp, zTemp, "%s", pOp->zComment);
     jj = sqlite3Strlen30(zTemp);
   }else{
     zTemp[0] = 0;
     jj = 0;
   }
   return jj;
 }
 #endif /* SQLITE_DEBUG */
 #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \
      || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
 /*

@@ -61543,17 +62348,20 @@ static char *displayP4(Op *pOp, char *zTemp, int nTemp){

   char *zP4 = zTemp;
   assert( nTemp>=20 );
   switch( pOp->p4type ){
     case P4_KEYINFO_STATIC:
     case P4_KEYINFO: {
       int i, j;
       KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
       assert( pKeyInfo->aSortOrder!=0 );
       sqlite3_snprintf(nTemp, zTemp, "keyinfo(%d", pKeyInfo->nField);
       sqlite3_snprintf(nTemp, zTemp, "k(%d", pKeyInfo->nField);
       i = sqlite3Strlen30(zTemp);
       for(j=0; j<pKeyInfo->nField; j++){
         CollSeq *pColl = pKeyInfo->aColl[j];
         const char *zColl = pColl ? pColl->zName : "nil";
         int n = sqlite3Strlen30(zColl);
         if( n==6 && memcmp(zColl,"BINARY",6)==0 ){
           zColl = "B";
           n = 1;
         }
         if( i+n>nTemp-6 ){
           memcpy(&zTemp[i],",...",4);
           break;

@@ -61572,7 +62380,7 @@ static char *displayP4(Op *pOp, char *zTemp, int nTemp){

     }
     case P4_COLLSEQ: {
       CollSeq *pColl = pOp->p4.pColl;
       sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
       sqlite3_snprintf(nTemp, zTemp, "(%.20s)", pColl->zName);
       break;
     }
     case P4_FUNCDEF: {

@@ -61726,16 +62534,21 @@ SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){

 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
   char *zP4;
   char zPtr[50];
   static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-4s %.2X %s\n";
   char zCom[100];
   static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-13s %.2X %s\n";
   if( pOut==0 ) pOut = stdout;
   zP4 = displayP4(pOp, zPtr, sizeof(zPtr));
   fprintf(pOut, zFormat1, pc,
       sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5,
 #ifdef SQLITE_DEBUG
       pOp->zComment ? pOp->zComment : ""
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
   displayComment(pOp, zP4, zCom, sizeof(zCom));
 #else
       ""
   zCom[0] = 0;
 #endif
   /* NB:  The sqlite3OpcodeName() function is implemented by code created
   ** by the mkopcodeh.awk and mkopcodec.awk scripts which extract the
   ** information from the vdbe.c source text */
   fprintf(pOut, zFormat1, pc,
       sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5,
       zCom
   );
   fflush(pOut);
 }

@@ -61757,6 +62570,7 @@ static void releaseMemArray(Mem *p, int N){

     }
     for(pEnd=&p[N]; p<pEnd; p++){
       assert( (&p[1])==pEnd || p[0].db==p[1].db );
       assert( sqlite3VdbeCheckMemInvariants(p) );
       /* This block is really an inlined version of sqlite3VdbeMemRelease()
       ** that takes advantage of the fact that the memory cell value is

@@ -61770,6 +62584,10 @@ static void releaseMemArray(Mem *p, int N){

       ** with no indexes using a single prepared INSERT statement, bind()
       ** and reset(). Inserts are grouped into a transaction.
       */
       testcase( p->flags & MEM_Agg );
       testcase( p->flags & MEM_Dyn );
       testcase( p->flags & MEM_Frame );
       testcase( p->flags & MEM_RowSet );
       if( p->flags&(MEM_Agg|MEM_Dyn|MEM_Frame|MEM_RowSet) ){
         sqlite3VdbeMemRelease(p);
       }else if( p->zMalloc ){

@@ -61777,7 +62595,7 @@ static void releaseMemArray(Mem *p, int N){

         p->zMalloc = 0;
       }
       p->flags = MEM_Invalid;
       p->flags = MEM_Undefined;
     }
     db->mallocFailed = malloc_failed;
   }

@@ -61881,7 +62699,7 @@ SQLITE_PRIVATE int sqlite3VdbeList(

     rc = SQLITE_ERROR;
     sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(p->rc));
   }else{
     char *z;
     char *zP4;
     Op *pOp;
     if( i<p->nOp ){
       /* The output line number is small enough that we are still in the

@@ -61899,15 +62717,13 @@ SQLITE_PRIVATE int sqlite3VdbeList(

     }
     if( p->explain==1 ){
       pMem->flags = MEM_Int;
       pMem->type = SQLITE_INTEGER;
       pMem->u.i = i;                                /* Program counter */
       pMem++;
       pMem->flags = MEM_Static|MEM_Str|MEM_Term;
       pMem->z = (char*)sqlite3OpcodeName(pOp->opcode);  /* Opcode */
       pMem->z = (char*)sqlite3OpcodeName(pOp->opcode); /* Opcode */
       assert( pMem->z!=0 );
       pMem->n = sqlite3Strlen30(pMem->z);
       pMem->type = SQLITE_TEXT;
       pMem->enc = SQLITE_UTF8;
       pMem++;

@@ -61933,33 +62749,29 @@ SQLITE_PRIVATE int sqlite3VdbeList(

     pMem->flags = MEM_Int;
     pMem->u.i = pOp->p1;                          /* P1 */
     pMem->type = SQLITE_INTEGER;
     pMem++;
     pMem->flags = MEM_Int;
     pMem->u.i = pOp->p2;                          /* P2 */
     pMem->type = SQLITE_INTEGER;
     pMem++;
     pMem->flags = MEM_Int;
     pMem->u.i = pOp->p3;                          /* P3 */
     pMem->type = SQLITE_INTEGER;
     pMem++;
     if( sqlite3VdbeMemGrow(pMem, 32, 0) ){            /* P4 */
       assert( p->db->mallocFailed );
       return SQLITE_ERROR;
     }
     pMem->flags = MEM_Dyn|MEM_Str|MEM_Term;
     z = displayP4(pOp, pMem->z, 32);
     if( z!=pMem->z ){
       sqlite3VdbeMemSetStr(pMem, z, -1, SQLITE_UTF8, 0);
     pMem->flags = MEM_Str|MEM_Term;
     zP4 = displayP4(pOp, pMem->z, 32);
     if( zP4!=pMem->z ){
       sqlite3VdbeMemSetStr(pMem, zP4, -1, SQLITE_UTF8, 0);
     }else{
       assert( pMem->z!=0 );
       pMem->n = sqlite3Strlen30(pMem->z);
       pMem->enc = SQLITE_UTF8;
     }
     pMem->type = SQLITE_TEXT;
     pMem++;
     if( p->explain==1 ){

@@ -61967,26 +62779,23 @@ SQLITE_PRIVATE int sqlite3VdbeList(

         assert( p->db->mallocFailed );
         return SQLITE_ERROR;
       }
       pMem->flags = MEM_Dyn|MEM_Str|MEM_Term;
       pMem->flags = MEM_Str|MEM_Term;
       pMem->n = 2;
       sqlite3_snprintf(3, pMem->z, "%.2x", pOp->p5);   /* P5 */
       pMem->type = SQLITE_TEXT;
       pMem->enc = SQLITE_UTF8;
       pMem++;
 #ifdef SQLITE_DEBUG
       if( pOp->zComment ){
         pMem->flags = MEM_Str|MEM_Term;
         pMem->z = pOp->zComment;
         pMem->n = sqlite3Strlen30(pMem->z);
         pMem->enc = SQLITE_UTF8;
         pMem->type = SQLITE_TEXT;
       }else
 #endif
       {
         pMem->flags = MEM_Null;                       /* Comment */
         pMem->type = SQLITE_NULL;
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
       if( sqlite3VdbeMemGrow(pMem, 500, 0) ){
         assert( p->db->mallocFailed );
         return SQLITE_ERROR;
       }
       pMem->flags = MEM_Str|MEM_Term;
       pMem->n = displayComment(pOp, zP4, pMem->z, 500);
       pMem->enc = SQLITE_UTF8;
 #else
       pMem->flags = MEM_Null;                       /* Comment */
 #endif
     }
     p->nResColumn = 8 - 4*(p->explain-1);

@@ -62003,15 +62812,17 @@ SQLITE_PRIVATE int sqlite3VdbeList(

 ** Print the SQL that was used to generate a VDBE program.
 */
 SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe *p){
   int nOp = p->nOp;
   VdbeOp *pOp;
   if( nOp<1 ) return;
   pOp = &p->aOp[0];
   if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){
     const char *z = pOp->p4.z;
     while( sqlite3Isspace(*z) ) z++;
     printf("SQL: [%s]\n", z);
   const char *z = 0;
   if( p->zSql ){
     z = p->zSql;
   }else if( p->nOp>=1 ){
     const VdbeOp *pOp = &p->aOp[0];
     if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
       z = pOp->p4.z;
       while( sqlite3Isspace(*z) ) z++;
     }
   }
   if( z ) printf("SQL: [%s]\n", z);
 }
 #endif

@@ -62025,7 +62836,7 @@ SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){

   if( sqlite3IoTrace==0 ) return;
   if( nOp<1 ) return;
   pOp = &p->aOp[0];
   if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){
   if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
     int i, j;
     char z[1000];
     sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);

@@ -62162,6 +62973,7 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(

   assert( p->nOp>0 );
   assert( pParse!=0 );
   assert( p->magic==VDBE_MAGIC_INIT );
   assert( pParse==p->pParse );
   db = p->db;
   assert( db->mallocFailed==0 );
   nVar = pParse->nVar;

@@ -62185,8 +62997,8 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(

   /* Allocate space for memory registers, SQL variables, VDBE cursors and
   ** an array to marshal SQL function arguments in.
   */
   zCsr = (u8*)&p->aOp[p->nOp];       /* Memory avaliable for allocation */
   zEnd = (u8*)&p->aOp[p->nOpAlloc];  /* First byte past end of zCsr[] */
   zCsr = (u8*)&p->aOp[p->nOp];            /* Memory avaliable for allocation */
   zEnd = (u8*)&p->aOp[pParse->nOpAlloc];  /* First byte past end of zCsr[] */
   resolveP2Values(p, &nArg);
   p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);

@@ -62242,7 +63054,7 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(

     p->aMem--;                      /* aMem[] goes from 1..nMem */
     p->nMem = nMem;                 /*       not from 0..nMem-1 */
     for(n=1; n<=nMem; n++){
       p->aMem[n].flags = MEM_Invalid;
       p->aMem[n].flags = MEM_Undefined;
       p->aMem[n].db = db;
     }
   }

@@ -62269,7 +63081,7 @@ SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){

 #ifndef SQLITE_OMIT_VIRTUALTABLE
   if( pCx->pVtabCursor ){
     sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor;
     const sqlite3_module *pModule = pCx->pModule;
     const sqlite3_module *pModule = pVtabCursor->pVtab->pModule;
     p->inVtabMethod = 1;
     pModule->xClose(pVtabCursor);
     p->inVtabMethod = 0;

@@ -62354,7 +63166,7 @@ static void Cleanup(Vdbe *p){

   int i;
   if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
   if( p->aMem ){
     for(i=1; i<=p->nMem; i++) assert( p->aMem[i].flags==MEM_Invalid );
     for(i=1; i<=p->nMem; i++) assert( p->aMem[i].flags==MEM_Undefined );
   }
 #endif

@@ -62777,7 +63589,7 @@ SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){

   ){
     p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;
     p->errorAction = OE_Abort;
     sqlite3SetString(&p->zErrMsg, db, "foreign key constraint failed");
     sqlite3SetString(&p->zErrMsg, db, "FOREIGN KEY constraint failed");
     return SQLITE_ERROR;
   }
   return SQLITE_OK;

@@ -63013,6 +63825,7 @@ SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){

   if( p->zErrMsg ){
     u8 mallocFailed = db->mallocFailed;
     sqlite3BeginBenignMalloc();
     if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
     sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
     sqlite3EndBenignMalloc();
     db->mallocFailed = mallocFailed;

@@ -63081,8 +63894,7 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){

     ** to sqlite3_step(). For consistency (since sqlite3_step() was
     ** called), set the database error in this case as well.
     */
     sqlite3Error(db, p->rc, 0);
     sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
     sqlite3Error(db, p->rc, p->zErrMsg ? "%s" : 0, p->zErrMsg);
     sqlite3DbFree(db, p->zErrMsg);
     p->zErrMsg = 0;
   }

@@ -63103,12 +63915,24 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){

         fprintf(out, "%02x", p->aOp[i].opcode);
       }
       fprintf(out, "\n");
       if( p->zSql ){
         char c, pc = 0;
         fprintf(out, "-- ");
         for(i=0; (c = p->zSql[i])!=0; i++){
           if( pc=='\n' ) fprintf(out, "-- ");
           putc(c, out);
           pc = c;
         }
         if( pc!='\n' ) fprintf(out, "\n");
       }
       for(i=0; i<p->nOp; i++){
         fprintf(out, "%6d %10lld %8lld ",
         char zHdr[100];
         sqlite3_snprintf(sizeof(zHdr), zHdr, "%6u %12llu %8llu ",
            p->aOp[i].cnt,
            p->aOp[i].cycles,
            p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
         );
         fprintf(out, "%s", zHdr);
         sqlite3VdbePrintOp(out, i, &p->aOp[i]);
       }
       fclose(out);

@@ -63155,8 +63979,9 @@ SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(Vdbe *pVdbe, int iOp, int mask){

   while( *pp ){
     AuxData *pAux = *pp;
     if( (iOp<0)
      || (pAux->iOp==iOp && (pAux->iArg>31 || !(mask & ((u32)1<<pAux->iArg))))
      || (pAux->iOp==iOp && (pAux->iArg>31 || !(mask & MASKBIT32(pAux->iArg))))
     ){
       testcase( pAux->iArg==31 );
       if( pAux->xDelete ){
         pAux->xDelete(pAux->pAux);
       }

@@ -63189,7 +64014,6 @@ SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){

   }
   for(i=p->nzVar-1; i>=0; i--) sqlite3DbFree(db, p->azVar[i]);
   vdbeFreeOpArray(db, p->aOp, p->nOp);
   sqlite3DbFree(db, p->aLabel);
   sqlite3DbFree(db, p->aColName);
   sqlite3DbFree(db, p->zSql);
   sqlite3DbFree(db, p->pFree);

@@ -63253,7 +64077,7 @@ SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor *p){

 #endif
     p->deferredMoveto = 0;
     p->cacheStatus = CACHE_STALE;
   }else if( ALWAYS(p->pCursor) ){
   }else if( p->pCursor ){
     int hasMoved;
     int rc = sqlite3BtreeCursorHasMoved(p->pCursor, &hasMoved);
     if( rc ) return rc;

@@ -63420,21 +64244,15 @@ static u64 floatSwap(u64 in){

 ** buf. It is assumed that the caller has allocated sufficient space.
 ** Return the number of bytes written.
 **
 ** nBuf is the amount of space left in buf[].  nBuf must always be
 ** large enough to hold the entire field.  Except, if the field is
 ** a blob with a zero-filled tail, then buf[] might be just the right
 ** size to hold everything except for the zero-filled tail.  If buf[]
 ** is only big enough to hold the non-zero prefix, then only write that
 ** prefix into buf[].  But if buf[] is large enough to hold both the
 ** prefix and the tail then write the prefix and set the tail to all
 ** zeros.
 ** nBuf is the amount of space left in buf[].  The caller is responsible
 ** for allocating enough space to buf[] to hold the entire field, exclusive
 ** of the pMem->u.nZero bytes for a MEM_Zero value.
 **
 ** Return the number of bytes actually written into buf[].  The number
 ** of bytes in the zero-filled tail is included in the return value only
 ** if those bytes were zeroed in buf[].
 */
 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
   u32 serial_type = sqlite3VdbeSerialType(pMem, file_format);
 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){
   u32 len;
   /* Integer and Real */

@@ -63449,7 +64267,6 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_f

       v = pMem->u.i;
     }
     len = i = sqlite3VdbeSerialTypeLen(serial_type);
     assert( len<=(u32)nBuf );
     while( i-- ){
       buf[i] = (u8)(v&0xFF);
       v >>= 8;

@@ -63461,17 +64278,8 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_f

   if( serial_type>=12 ){
     assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
              == (int)sqlite3VdbeSerialTypeLen(serial_type) );
     assert( pMem->n<=nBuf );
     len = pMem->n;
     memcpy(buf, pMem->z, len);
     if( pMem->flags & MEM_Zero ){
       len += pMem->u.nZero;
       assert( nBuf>=0 );
       if( len > (u32)nBuf ){
         len = (u32)nBuf;
       }
       memset(&buf[pMem->n], 0, len-pMem->n);
     }
     return len;
   }

@@ -63479,6 +64287,14 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_f

   return 0;
 }
 /* Input "x" is a sequence of unsigned characters that represent a
 ** big-endian integer.  Return the equivalent native integer
 */
 #define ONE_BYTE_INT(x)    ((i8)(x)[0])
 #define TWO_BYTE_INT(x)    (256*(i8)((x)[0])|(x)[1])
 #define THREE_BYTE_INT(x)  (65536*(i8)((x)[0])|((x)[1]<<8)|(x)[2])
 #define FOUR_BYTE_UINT(x)  (((u32)(x)[0]<<24)|((x)[1]<<16)|((x)[2]<<8)|(x)[3])
 /*
 ** Deserialize the data blob pointed to by buf as serial type serial_type
 ** and store the result in pMem.  Return the number of bytes read.

@@ -63488,6 +64304,8 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(

   u32 serial_type,              /* Serial type to deserialize */
   Mem *pMem                     /* Memory cell to write value into */
 ){
   u64 x;
   u32 y;
   switch( serial_type ){
     case 10:   /* Reserved for future use */
     case 11:   /* Reserved for future use */

@@ -63496,37 +64314,38 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(

       break;
     }
     case 1: { /* 1-byte signed integer */
       pMem->u.i = (signed char)buf[0];
       pMem->u.i = ONE_BYTE_INT(buf);
       pMem->flags = MEM_Int;
       testcase( pMem->u.i<0 );
       return 1;
     }
     case 2: { /* 2-byte signed integer */
       pMem->u.i = (((signed char)buf[0])<<8) | buf[1];
       pMem->u.i = TWO_BYTE_INT(buf);
       pMem->flags = MEM_Int;
       testcase( pMem->u.i<0 );
       return 2;
     }
     case 3: { /* 3-byte signed integer */
       pMem->u.i = (((signed char)buf[0])<<16) | (buf[1]<<8) | buf[2];
       pMem->u.i = THREE_BYTE_INT(buf);
       pMem->flags = MEM_Int;
       testcase( pMem->u.i<0 );
       return 3;
     }
     case 4: { /* 4-byte signed integer */
       pMem->u.i = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
       y = FOUR_BYTE_UINT(buf);
       pMem->u.i = (i64)*(int*)&y;
       pMem->flags = MEM_Int;
       testcase( pMem->u.i<0 );
       return 4;
     }
     case 5: { /* 6-byte signed integer */
       u64 x = (((signed char)buf[0])<<8) | buf[1];
       u32 y = (buf[2]<<24) | (buf[3]<<16) | (buf[4]<<8) | buf[5];
       x = (x<<32) | y;
       pMem->u.i = *(i64*)&x;
       pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf);
       pMem->flags = MEM_Int;
       testcase( pMem->u.i<0 );
       return 6;
     }
     case 6:   /* 8-byte signed integer */
     case 7: { /* IEEE floating point */
       u64 x;
       u32 y;
 #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
       /* Verify that integers and floating point values use the same
       ** byte order.  Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is

@@ -63539,13 +64358,13 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(

       swapMixedEndianFloat(t2);
       assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
 #endif
       x = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
       y = (buf[4]<<24) | (buf[5]<<16) | (buf[6]<<8) | buf[7];
       x = FOUR_BYTE_UINT(buf);
       y = FOUR_BYTE_UINT(buf+4);
       x = (x<<32) | y;
       if( serial_type==6 ){
         pMem->u.i = *(i64*)&x;
         pMem->flags = MEM_Int;
         testcase( pMem->u.i<0 );
       }else{
         assert( sizeof(x)==8 && sizeof(pMem->r)==8 );
         swapMixedEndianFloat(x);

@@ -63561,15 +64380,12 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(

       return 0;
     }
     default: {
       static const u16 aFlag[] = { MEM_Blob|MEM_Ephem, MEM_Str|MEM_Ephem };
       u32 len = (serial_type-12)/2;
       pMem->z = (char *)buf;
       pMem->n = len;
       pMem->xDel = 0;
       if( serial_type&0x01 ){
         pMem->flags = MEM_Str | MEM_Ephem;
       }else{
         pMem->flags = MEM_Blob | MEM_Ephem;
       }
       pMem->flags = aFlag[serial_type&1];
       return len;
     }
   }

@@ -63640,7 +64456,7 @@ SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(

   u32 szHdr;
   Mem *pMem = p->aMem;
   p->flags = 0;
   p->default_rc = 0;
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
   idx = getVarint32(aKey, szHdr);
   d = szHdr;

@@ -63661,26 +64477,18 @@ SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(

   p->nField = u;
 }
 #if SQLITE_DEBUG
 /*
 ** This function compares the two table rows or index records
 ** specified by {nKey1, pKey1} and pPKey2.  It returns a negative, zero
 ** or positive integer if key1 is less than, equal to or
 ** greater than key2.  The {nKey1, pKey1} key must be a blob
 ** created by th OP_MakeRecord opcode of the VDBE.  The pPKey2
 ** key must be a parsed key such as obtained from
 ** sqlite3VdbeParseRecord.
 **
 ** Key1 and Key2 do not have to contain the same number of fields.
 ** The key with fewer fields is usually compares less than the
 ** longer key.  However if the UNPACKED_INCRKEY flags in pPKey2 is set
 ** and the common prefixes are equal, then key1 is less than key2.
 ** Or if the UNPACKED_MATCH_PREFIX flag is set and the prefixes are
 ** equal, then the keys are considered to be equal and
 ** the parts beyond the common prefix are ignored.
 ** This function compares two index or table record keys in the same way
 ** as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(),
 ** this function deserializes and compares values using the
 ** sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used
 ** in assert() statements to ensure that the optimized code in
 ** sqlite3VdbeRecordCompare() returns results with these two primitives.
 */
 SQLITE_PRIVATE int sqlite3VdbeRecordCompare(
 static int vdbeRecordCompareDebug(
   int nKey1, const void *pKey1, /* Left key */
   UnpackedRecord *pPKey2        /* Right key */
   const UnpackedRecord *pPKey2  /* Right key */
 ){
   u32 d1;            /* Offset into aKey[] of next data element */
   u32 idx1;          /* Offset into aKey[] of next header element */

@@ -63708,9 +64516,11 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompare(

   idx1 = getVarint32(aKey1, szHdr1);
   d1 = szHdr1;
   assert( pKeyInfo->nField+1>=pPKey2->nField );
   assert( pKeyInfo->nField+pKeyInfo->nXField>=pPKey2->nField || CORRUPT_DB );
   assert( pKeyInfo->aSortOrder!=0 );
   while( idx1<szHdr1 && i<pPKey2->nField ){
   assert( pKeyInfo->nField>0 );
   assert( idx1<=szHdr1 || CORRUPT_DB );
   do{
     u32 serial_type1;
     /* Read the serial types for the next element in each key. */

@@ -63737,28 +64547,13 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompare(

     rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], pKeyInfo->aColl[i]);
     if( rc!=0 ){
       assert( mem1.zMalloc==0 );  /* See comment below */
       /* Invert the result if we are using DESC sort order. */
       if( pKeyInfo->aSortOrder[i] ){
         rc = -rc;
         rc = -rc;  /* Invert the result for DESC sort order. */
       }
       /* If the PREFIX_SEARCH flag is set and all fields except the final
       ** rowid field were equal, then clear the PREFIX_SEARCH flag and set
       ** pPKey2->rowid to the value of the rowid field in (pKey1, nKey1).
       ** This is used by the OP_IsUnique opcode.
       */
       if( (pPKey2->flags & UNPACKED_PREFIX_SEARCH) && i==(pPKey2->nField-1) ){
         assert( idx1==szHdr1 && rc );
         assert( mem1.flags & MEM_Int );
         pPKey2->flags &= ~UNPACKED_PREFIX_SEARCH;
         pPKey2->rowid = mem1.u.i;
       }
       return rc;
     }
     i++;
   }
   }while( idx1<szHdr1 && i<pPKey2->nField );
   /* No memory allocation is ever used on mem1.  Prove this using
   ** the following assert().  If the assert() fails, it indicates a

@@ -63767,24 +64562,576 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompare(

   assert( mem1.zMalloc==0 );
   /* rc==0 here means that one of the keys ran out of fields and
   ** all the fields up to that point were equal. If the UNPACKED_INCRKEY
   ** flag is set, then break the tie by treating key2 as larger.
   ** If the UPACKED_PREFIX_MATCH flag is set, then keys with common prefixes
   ** are considered to be equal.  Otherwise, the longer key is the
   ** larger.  As it happens, the pPKey2 will always be the longer
   ** if there is a difference.
   */
   assert( rc==0 );
   if( pPKey2->flags & UNPACKED_INCRKEY ){
     rc = -1;
   }else if( pPKey2->flags & UNPACKED_PREFIX_MATCH ){
     /* Leave rc==0 */
   }else if( idx1<szHdr1 ){
     rc = 1;
   ** all the fields up to that point were equal. Return the the default_rc
   ** value.  */
   return pPKey2->default_rc;
 }
 #endif
 /*
 ** Both *pMem1 and *pMem2 contain string values. Compare the two values
 ** using the collation sequence pColl. As usual, return a negative , zero
 ** or positive value if *pMem1 is less than, equal to or greater than
 ** *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);".
 */
 static int vdbeCompareMemString(
   const Mem *pMem1,
   const Mem *pMem2,
   const CollSeq *pColl
 ){
   if( pMem1->enc==pColl->enc ){
     /* The strings are already in the correct encoding.  Call the
      ** comparison function directly */
     return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
   }else{
     int rc;
     const void *v1, *v2;
     int n1, n2;
     Mem c1;
     Mem c2;
     memset(&c1, 0, sizeof(c1));
     memset(&c2, 0, sizeof(c2));
     sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
     sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
     v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
     n1 = v1==0 ? 0 : c1.n;
     v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
     n2 = v2==0 ? 0 : c2.n;
     rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
     sqlite3VdbeMemRelease(&c1);
     sqlite3VdbeMemRelease(&c2);
     return rc;
   }
   return rc;
 }
 /*
 ** Compare the values contained by the two memory cells, returning
 ** negative, zero or positive if pMem1 is less than, equal to, or greater
 ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
 ** and reals) sorted numerically, followed by text ordered by the collating
 ** sequence pColl and finally blob's ordered by memcmp().
 **
 ** Two NULL values are considered equal by this function.
 */
 SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
   int rc;
   int f1, f2;
   int combined_flags;
   f1 = pMem1->flags;
   f2 = pMem2->flags;
   combined_flags = f1|f2;
   assert( (combined_flags & MEM_RowSet)==0 );
   /* If one value is NULL, it is less than the other. If both values
   ** are NULL, return 0.
   */
   if( combined_flags&MEM_Null ){
     return (f2&MEM_Null) - (f1&MEM_Null);
   }
   /* If one value is a number and the other is not, the number is less.
   ** If both are numbers, compare as reals if one is a real, or as integers
   ** if both values are integers.
   */
   if( combined_flags&(MEM_Int|MEM_Real) ){
     double r1, r2;
     if( (f1 & f2 & MEM_Int)!=0 ){
       if( pMem1->u.i < pMem2->u.i ) return -1;
       if( pMem1->u.i > pMem2->u.i ) return 1;
       return 0;
     }
     if( (f1&MEM_Real)!=0 ){
       r1 = pMem1->r;
     }else if( (f1&MEM_Int)!=0 ){
       r1 = (double)pMem1->u.i;
     }else{
       return 1;
     }
     if( (f2&MEM_Real)!=0 ){
       r2 = pMem2->r;
     }else if( (f2&MEM_Int)!=0 ){
       r2 = (double)pMem2->u.i;
     }else{
       return -1;
     }
     if( r1<r2 ) return -1;
     if( r1>r2 ) return 1;
     return 0;
   }
   /* If one value is a string and the other is a blob, the string is less.
   ** If both are strings, compare using the collating functions.
   */
   if( combined_flags&MEM_Str ){
     if( (f1 & MEM_Str)==0 ){
       return 1;
     }
     if( (f2 & MEM_Str)==0 ){
       return -1;
     }
     assert( pMem1->enc==pMem2->enc );
     assert( pMem1->enc==SQLITE_UTF8 ||
             pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
     /* The collation sequence must be defined at this point, even if
     ** the user deletes the collation sequence after the vdbe program is
     ** compiled (this was not always the case).
     */
     assert( !pColl || pColl->xCmp );
     if( pColl ){
       return vdbeCompareMemString(pMem1, pMem2, pColl);
     }
     /* If a NULL pointer was passed as the collate function, fall through
     ** to the blob case and use memcmp().  */
   }
   /* Both values must be blobs.  Compare using memcmp().  */
   rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n);
   if( rc==0 ){
     rc = pMem1->n - pMem2->n;
   }
   return rc;
 }
 /*
 ** The first argument passed to this function is a serial-type that
 ** corresponds to an integer - all values between 1 and 9 inclusive
 ** except 7. The second points to a buffer containing an integer value
 ** serialized according to serial_type. This function deserializes
 ** and returns the value.
 */
 static i64 vdbeRecordDecodeInt(u32 serial_type, const u8 *aKey){
   u32 y;
   assert( CORRUPT_DB || (serial_type>=1 && serial_type<=9 && serial_type!=7) );
   switch( serial_type ){
     case 0:
     case 1:
       testcase( aKey[0]&0x80 );
       return ONE_BYTE_INT(aKey);
     case 2:
       testcase( aKey[0]&0x80 );
       return TWO_BYTE_INT(aKey);
     case 3:
       testcase( aKey[0]&0x80 );
       return THREE_BYTE_INT(aKey);
     case 4: {
       testcase( aKey[0]&0x80 );
       y = FOUR_BYTE_UINT(aKey);
       return (i64)*(int*)&y;
     }
     case 5: {
       testcase( aKey[0]&0x80 );
       return FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey);
     }
     case 6: {
       u64 x = FOUR_BYTE_UINT(aKey);
       testcase( aKey[0]&0x80 );
       x = (x<<32) | FOUR_BYTE_UINT(aKey+4);
       return (i64)*(i64*)&x;
     }
   }
   return (serial_type - 8);
 }
 /*
 ** This function compares the two table rows or index records
 ** specified by {nKey1, pKey1} and pPKey2.  It returns a negative, zero
 ** or positive integer if key1 is less than, equal to or
 ** greater than key2.  The {nKey1, pKey1} key must be a blob
 ** created by th OP_MakeRecord opcode of the VDBE.  The pPKey2
 ** key must be a parsed key such as obtained from
 ** sqlite3VdbeParseRecord.
 **
 ** If argument bSkip is non-zero, it is assumed that the caller has already
 ** determined that the first fields of the keys are equal.
 **
 ** Key1 and Key2 do not have to contain the same number of fields. If all
 ** fields that appear in both keys are equal, then pPKey2->default_rc is
 ** returned.
 */
 SQLITE_PRIVATE int sqlite3VdbeRecordCompare(
   int nKey1, const void *pKey1,   /* Left key */
   const UnpackedRecord *pPKey2,   /* Right key */
   int bSkip                       /* If true, skip the first field */
 ){
   u32 d1;                         /* Offset into aKey[] of next data element */
   int i;                          /* Index of next field to compare */
   u32 szHdr1;                     /* Size of record header in bytes */
   u32 idx1;                       /* Offset of first type in header */
   int rc = 0;                     /* Return value */
   Mem *pRhs = pPKey2->aMem;       /* Next field of pPKey2 to compare */
   KeyInfo *pKeyInfo = pPKey2->pKeyInfo;
   const unsigned char *aKey1 = (const unsigned char *)pKey1;
   Mem mem1;
   /* If bSkip is true, then the caller has already determined that the first
   ** two elements in the keys are equal. Fix the various stack variables so
   ** that this routine begins comparing at the second field. */
   if( bSkip ){
     u32 s1;
     idx1 = 1 + getVarint32(&aKey1[1], s1);
     szHdr1 = aKey1[0];
     d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1);
     i = 1;
     pRhs++;
   }else{
     idx1 = getVarint32(aKey1, szHdr1);
     d1 = szHdr1;
     i = 0;
   }
   VVA_ONLY( mem1.zMalloc = 0; ) /* Only needed by assert() statements */
   assert( pPKey2->pKeyInfo->nField+pPKey2->pKeyInfo->nXField>=pPKey2->nField
        || CORRUPT_DB );
   assert( pPKey2->pKeyInfo->aSortOrder!=0 );
   assert( pPKey2->pKeyInfo->nField>0 );
   assert( idx1<=szHdr1 || CORRUPT_DB );
   do{
     u32 serial_type;
     /* RHS is an integer */
     if( pRhs->flags & MEM_Int ){
       serial_type = aKey1[idx1];
       testcase( serial_type==12 );
       if( serial_type>=12 ){
         rc = +1;
       }else if( serial_type==0 ){
         rc = -1;
       }else if( serial_type==7 ){
         double rhs = (double)pRhs->u.i;
         sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
         if( mem1.r<rhs ){
           rc = -1;
         }else if( mem1.r>rhs ){
           rc = +1;
         }
       }else{
         i64 lhs = vdbeRecordDecodeInt(serial_type, &aKey1[d1]);
         i64 rhs = pRhs->u.i;
         if( lhs<rhs ){
           rc = -1;
         }else if( lhs>rhs ){
           rc = +1;
         }
       }
     }
     /* RHS is real */
     else if( pRhs->flags & MEM_Real ){
       serial_type = aKey1[idx1];
       if( serial_type>=12 ){
         rc = +1;
       }else if( serial_type==0 ){
         rc = -1;
       }else{
         double rhs = pRhs->r;
         double lhs;
         sqlite3VdbeSerialGet(&aKey1[d1], serial_type, &mem1);
         if( serial_type==7 ){
           lhs = mem1.r;
         }else{
           lhs = (double)mem1.u.i;
         }
         if( lhs<rhs ){
           rc = -1;
         }else if( lhs>rhs ){
           rc = +1;
         }
       }
     }
     /* RHS is a string */
     else if( pRhs->flags & MEM_Str ){
       getVarint32(&aKey1[idx1], serial_type);
       testcase( serial_type==12 );
       if( serial_type<12 ){
         rc = -1;
       }else if( !(serial_type & 0x01) ){
         rc = +1;
       }else{
         mem1.n = (serial_type - 12) / 2;
         testcase( (d1+mem1.n)==(unsigned)nKey1 );
         testcase( (d1+mem1.n+1)==(unsigned)nKey1 );
         if( (d1+mem1.n) > (unsigned)nKey1 ){
           rc = 1;                /* Corruption */
         }else if( pKeyInfo->aColl[i] ){
           mem1.enc = pKeyInfo->enc;
           mem1.db = pKeyInfo->db;
           mem1.flags = MEM_Str;
           mem1.z = (char*)&aKey1[d1];
           rc = vdbeCompareMemString(&mem1, pRhs, pKeyInfo->aColl[i]);
         }else{
           int nCmp = MIN(mem1.n, pRhs->n);
           rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
           if( rc==0 ) rc = mem1.n - pRhs->n;
         }
       }
     }
     /* RHS is a blob */
     else if( pRhs->flags & MEM_Blob ){
       getVarint32(&aKey1[idx1], serial_type);
       testcase( serial_type==12 );
       if( serial_type<12 || (serial_type & 0x01) ){
         rc = -1;
       }else{
         int nStr = (serial_type - 12) / 2;
         testcase( (d1+nStr)==(unsigned)nKey1 );
         testcase( (d1+nStr+1)==(unsigned)nKey1 );
         if( (d1+nStr) > (unsigned)nKey1 ){
           rc = 1;                /* Corruption */
         }else{
           int nCmp = MIN(nStr, pRhs->n);
           rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
           if( rc==0 ) rc = nStr - pRhs->n;
         }
       }
     }
     /* RHS is null */
     else{
       serial_type = aKey1[idx1];
       rc = (serial_type!=0);
     }
     if( rc!=0 ){
       if( pKeyInfo->aSortOrder[i] ){
         rc = -rc;
       }
       assert( CORRUPT_DB
           || (rc<0 && vdbeRecordCompareDebug(nKey1, pKey1, pPKey2)<0)
           || (rc>0 && vdbeRecordCompareDebug(nKey1, pKey1, pPKey2)>0)
           || pKeyInfo->db->mallocFailed
       );
       assert( mem1.zMalloc==0 );  /* See comment below */
       return rc;
     }
     i++;
     pRhs++;
     d1 += sqlite3VdbeSerialTypeLen(serial_type);
     idx1 += sqlite3VarintLen(serial_type);
   }while( idx1<(unsigned)szHdr1 && i<pPKey2->nField && d1<=(unsigned)nKey1 );
   /* No memory allocation is ever used on mem1.  Prove this using
   ** the following assert().  If the assert() fails, it indicates a
   ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).  */
   assert( mem1.zMalloc==0 );
   /* rc==0 here means that one or both of the keys ran out of fields and
   ** all the fields up to that point were equal. Return the the default_rc
   ** value.  */
   assert( CORRUPT_DB
        || pPKey2->default_rc==vdbeRecordCompareDebug(nKey1, pKey1, pPKey2)
   );
   return pPKey2->default_rc;
 }
 /*
 ** This function is an optimized version of sqlite3VdbeRecordCompare()
 ** that (a) the first field of pPKey2 is an integer, and (b) the
 ** size-of-header varint at the start of (pKey1/nKey1) fits in a single
 ** byte (i.e. is less than 128).
 */
 static int vdbeRecordCompareInt(
   int nKey1, const void *pKey1, /* Left key */
   const UnpackedRecord *pPKey2, /* Right key */
   int bSkip                     /* Ignored */
 ){
   const u8 *aKey = &((const u8*)pKey1)[*(const u8*)pKey1 & 0x3F];
   int serial_type = ((const u8*)pKey1)[1];
   int res;
   u32 y;
   u64 x;
   i64 v = pPKey2->aMem[0].u.i;
   i64 lhs;
   UNUSED_PARAMETER(bSkip);
   assert( bSkip==0 );
   switch( serial_type ){
     case 1: { /* 1-byte signed integer */
       lhs = ONE_BYTE_INT(aKey);
       testcase( lhs<0 );
       break;
     }
     case 2: { /* 2-byte signed integer */
       lhs = TWO_BYTE_INT(aKey);
       testcase( lhs<0 );
       break;
     }
     case 3: { /* 3-byte signed integer */
       lhs = THREE_BYTE_INT(aKey);
       testcase( lhs<0 );
       break;
     }
     case 4: { /* 4-byte signed integer */
       y = FOUR_BYTE_UINT(aKey);
       lhs = (i64)*(int*)&y;
       testcase( lhs<0 );
       break;
     }
     case 5: { /* 6-byte signed integer */
       lhs = FOUR_BYTE_UINT(aKey+2) + (((i64)1)<<32)*TWO_BYTE_INT(aKey);
       testcase( lhs<0 );
       break;
     }
     case 6: { /* 8-byte signed integer */
       x = FOUR_BYTE_UINT(aKey);
       x = (x<<32) | FOUR_BYTE_UINT(aKey+4);
       lhs = *(i64*)&x;
       testcase( lhs<0 );
       break;
     }
     case 8:
       lhs = 0;
       break;
     case 9:
       lhs = 1;
       break;
     /* This case could be removed without changing the results of running
     ** this code. Including it causes gcc to generate a faster switch
     ** statement (since the range of switch targets now starts at zero and
     ** is contiguous) but does not cause any duplicate code to be generated
     ** (as gcc is clever enough to combine the two like cases). Other
     ** compilers might be similar.  */
     case 0: case 7:
       return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2, 0);
     default:
       return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2, 0);
   }
   if( v>lhs ){
     res = pPKey2->r1;
   }else if( v<lhs ){
     res = pPKey2->r2;
   }else if( pPKey2->nField>1 ){
     /* The first fields of the two keys are equal. Compare the trailing
     ** fields.  */
     res = sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2, 1);
   }else{
     /* The first fields of the two keys are equal and there are no trailing
     ** fields. Return pPKey2->default_rc in this case. */
     res = pPKey2->default_rc;
   }
   assert( (res==0 && vdbeRecordCompareDebug(nKey1, pKey1, pPKey2)==0)
        || (res<0 && vdbeRecordCompareDebug(nKey1, pKey1, pPKey2)<0)
        || (res>0 && vdbeRecordCompareDebug(nKey1, pKey1, pPKey2)>0)
        || CORRUPT_DB
   );
   return res;
 }
 /*
 ** This function is an optimized version of sqlite3VdbeRecordCompare()
 ** that (a) the first field of pPKey2 is a string, that (b) the first field
 ** uses the collation sequence BINARY and (c) that the size-of-header varint
 ** at the start of (pKey1/nKey1) fits in a single byte.
 */
 static int vdbeRecordCompareString(
   int nKey1, const void *pKey1, /* Left key */
   const UnpackedRecord *pPKey2, /* Right key */
   int bSkip
 ){
   const u8 *aKey1 = (const u8*)pKey1;
   int serial_type;
   int res;
   UNUSED_PARAMETER(bSkip);
   assert( bSkip==0 );
   getVarint32(&aKey1[1], serial_type);
   if( serial_type<12 ){
     res = pPKey2->r1;      /* (pKey1/nKey1) is a number or a null */
   }else if( !(serial_type & 0x01) ){
     res = pPKey2->r2;      /* (pKey1/nKey1) is a blob */
   }else{
     int nCmp;
     int nStr;
     int szHdr = aKey1[0];
     nStr = (serial_type-12) / 2;
     if( (szHdr + nStr) > nKey1 ) return 0;    /* Corruption */
     nCmp = MIN( pPKey2->aMem[0].n, nStr );
     res = memcmp(&aKey1[szHdr], pPKey2->aMem[0].z, nCmp);
     if( res==0 ){
       res = nStr - pPKey2->aMem[0].n;
       if( res==0 ){
         if( pPKey2->nField>1 ){
           res = sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2, 1);
         }else{
           res = pPKey2->default_rc;
         }
       }else if( res>0 ){
         res = pPKey2->r2;
       }else{
         res = pPKey2->r1;
       }
     }else if( res>0 ){
       res = pPKey2->r2;
     }else{
       res = pPKey2->r1;
     }
   }
   assert( (res==0 && vdbeRecordCompareDebug(nKey1, pKey1, pPKey2)==0)
        || (res<0 && vdbeRecordCompareDebug(nKey1, pKey1, pPKey2)<0)
        || (res>0 && vdbeRecordCompareDebug(nKey1, pKey1, pPKey2)>0)
        || CORRUPT_DB
   );
   return res;
 }
 /*
 ** Return a pointer to an sqlite3VdbeRecordCompare() compatible function
 ** suitable for comparing serialized records to the unpacked record passed
 ** as the only argument.
 */
 SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){
   /* varintRecordCompareInt() and varintRecordCompareString() both assume
   ** that the size-of-header varint that occurs at the start of each record
   ** fits in a single byte (i.e. is 127 or less). varintRecordCompareInt()
   ** also assumes that it is safe to overread a buffer by at least the
   ** maximum possible legal header size plus 8 bytes. Because there is
   ** guaranteed to be at least 74 (but not 136) bytes of padding following each
   ** buffer passed to varintRecordCompareInt() this makes it convenient to
   ** limit the size of the header to 64 bytes in cases where the first field
   ** is an integer.
   **
   ** The easiest way to enforce this limit is to consider only records with
   ** 13 fields or less. If the first field is an integer, the maximum legal
   ** header size is (12*5 + 1 + 1) bytes.  */
   if( (p->pKeyInfo->nField + p->pKeyInfo->nXField)<=13 ){
     int flags = p->aMem[0].flags;
     if( p->pKeyInfo->aSortOrder[0] ){
       p->r1 = 1;
       p->r2 = -1;
     }else{
       p->r1 = -1;
       p->r2 = 1;
     }
     if( (flags & MEM_Int) ){
       return vdbeRecordCompareInt;
     }
     testcase( flags & MEM_Real );
     testcase( flags & MEM_Null );
     testcase( flags & MEM_Blob );
     if( (flags & (MEM_Real|MEM_Null|MEM_Blob))==0 && p->pKeyInfo->aColl[0]==0 ){
       assert( flags & MEM_Str );
       return vdbeRecordCompareString;
     }
   }
   return sqlite3VdbeRecordCompare;
 }
 /*
 ** pCur points at an index entry created using the OP_MakeRecord opcode.

@@ -63816,7 +65163,7 @@ SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){

   /* Read in the complete content of the index entry */
   memset(&m, 0, sizeof(m));
   rc = sqlite3VdbeMemFromBtree(pCur, 0, (int)nCellKey, 1, &m);
   rc = sqlite3VdbeMemFromBtree(pCur, 0, (u32)nCellKey, 1, &m);
   if( rc ){
     return rc;
   }

@@ -63875,9 +65222,9 @@ idx_rowid_corruption:

 ** of the keys prior to the final rowid, not the entire key.
 */
 SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(
   VdbeCursor *pC,             /* The cursor to compare against */
   UnpackedRecord *pUnpacked,  /* Unpacked version of key to compare against */
   int *res                    /* Write the comparison result here */
   VdbeCursor *pC,                  /* The cursor to compare against */
   const UnpackedRecord *pUnpacked, /* Unpacked version of key */
   int *res                         /* Write the comparison result here */
 ){
   i64 nCellKey = 0;
   int rc;

@@ -63887,19 +65234,18 @@ SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(

   assert( sqlite3BtreeCursorIsValid(pCur) );
   VVA_ONLY(rc =) sqlite3BtreeKeySize(pCur, &nCellKey);
   assert( rc==SQLITE_OK );    /* pCur is always valid so KeySize cannot fail */
   /* nCellKey will always be between 0 and 0xffffffff because of the say
   /* nCellKey will always be between 0 and 0xffffffff because of the way
   ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
   if( nCellKey<=0 || nCellKey>0x7fffffff ){
     *res = 0;
     return SQLITE_CORRUPT_BKPT;
   }
   memset(&m, 0, sizeof(m));
   rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (int)nCellKey, 1, &m);
   rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (u32)nCellKey, 1, &m);
   if( rc ){
     return rc;
   }
   assert( pUnpacked->flags & UNPACKED_PREFIX_MATCH );
   *res = sqlite3VdbeRecordCompare(m.n, m.z, pUnpacked);
   *res = sqlite3VdbeRecordCompare(m.n, m.z, pUnpacked, 0);
   sqlite3VdbeMemRelease(&m);
   return SQLITE_OK;
 }

@@ -63963,7 +65309,6 @@ SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff

       if( pRet ){
         sqlite3VdbeMemCopy((Mem *)pRet, pMem);
         sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8);
         sqlite3VdbeMemStoreType((Mem *)pRet);
       }
       return pRet;
     }

@@ -64137,7 +65482,6 @@ SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){

   Mem *p = (Mem*)pVal;
   if( p->flags & (MEM_Blob|MEM_Str) ){
     sqlite3VdbeMemExpandBlob(p);
     p->flags &= ~MEM_Str;
     p->flags |= MEM_Blob;
     return p->n ? p->z : 0;
   }else{

@@ -64174,7 +65518,41 @@ SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){

 }
 #endif /* SQLITE_OMIT_UTF16 */
 SQLITE_API int sqlite3_value_type(sqlite3_value* pVal){
   return pVal->type;
   static const u8 aType[] = {
      SQLITE_BLOB,     /* 0x00 */
      SQLITE_NULL,     /* 0x01 */
      SQLITE_TEXT,     /* 0x02 */
      SQLITE_NULL,     /* 0x03 */
      SQLITE_INTEGER,  /* 0x04 */
      SQLITE_NULL,     /* 0x05 */
      SQLITE_INTEGER,  /* 0x06 */
      SQLITE_NULL,     /* 0x07 */
      SQLITE_FLOAT,    /* 0x08 */
      SQLITE_NULL,     /* 0x09 */
      SQLITE_FLOAT,    /* 0x0a */
      SQLITE_NULL,     /* 0x0b */
      SQLITE_INTEGER,  /* 0x0c */
      SQLITE_NULL,     /* 0x0d */
      SQLITE_INTEGER,  /* 0x0e */
      SQLITE_NULL,     /* 0x0f */
      SQLITE_BLOB,     /* 0x10 */
      SQLITE_NULL,     /* 0x11 */
      SQLITE_TEXT,     /* 0x12 */
      SQLITE_NULL,     /* 0x13 */
      SQLITE_INTEGER,  /* 0x14 */
      SQLITE_NULL,     /* 0x15 */
      SQLITE_INTEGER,  /* 0x16 */
      SQLITE_NULL,     /* 0x17 */
      SQLITE_FLOAT,    /* 0x18 */
      SQLITE_NULL,     /* 0x19 */
      SQLITE_FLOAT,    /* 0x1a */
      SQLITE_NULL,     /* 0x1b */
      SQLITE_INTEGER,  /* 0x1c */
      SQLITE_NULL,     /* 0x1d */
      SQLITE_INTEGER,  /* 0x1e */
      SQLITE_NULL,     /* 0x1f */
   };
   return aType[pVal->flags&MEM_AffMask];
 }
 /**************************** sqlite3_result_  *******************************

@@ -64488,7 +65866,7 @@ SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){

     v->doingRerun = 1;
     assert( v->expired==0 );
   }
   if( rc2!=SQLITE_OK && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
   if( rc2!=SQLITE_OK ){
     /* This case occurs after failing to recompile an sql statement.
     ** The error message from the SQL compiler has already been loaded
     ** into the database handle. This block copies the error message

@@ -64498,6 +65876,7 @@ SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){

     ** sqlite3_errmsg() and sqlite3_errcode().
     */
     const char *zErr = (const char *)sqlite3_value_text(db->pErr);
     assert( zErr!=0 || db->mallocFailed );
     sqlite3DbFree(db, v->zErrMsg);
     if( !db->mallocFailed ){
       v->zErrMsg = sqlite3DbStrDup(db, zErr);

@@ -64694,6 +66073,30 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt){

   return pVm->nResColumn;
 }
 /*
 ** Return a pointer to static memory containing an SQL NULL value.
 */
 static const Mem *columnNullValue(void){
   /* Even though the Mem structure contains an element
   ** of type i64, on certain architectures (x86) with certain compiler
   ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
   ** instead of an 8-byte one. This all works fine, except that when
   ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
   ** that a Mem structure is located on an 8-byte boundary. To prevent
   ** these assert()s from failing, when building with SQLITE_DEBUG defined
   ** using gcc, we force nullMem to be 8-byte aligned using the magical
   ** __attribute__((aligned(8))) macro.  */
   static const Mem nullMem
 #if defined(SQLITE_DEBUG) && defined(__GNUC__)
     __attribute__((aligned(8)))
 #endif
     = {0, "", (double)0, {0}, 0, MEM_Null, 0,
 #ifdef SQLITE_DEBUG
 , 0,  /* pScopyFrom, pFiller */
 #endif
 , 0 };
   return &nullMem;
 }
 /*
 ** Check to see if column iCol of the given statement is valid.  If

@@ -64710,32 +66113,11 @@ static Mem *columnMem(sqlite3_stmt *pStmt, int i){

     sqlite3_mutex_enter(pVm->db->mutex);
     pOut = &pVm->pResultSet[i];
   }else{
     /* If the value passed as the second argument is out of range, return
     ** a pointer to the following static Mem object which contains the
     ** value SQL NULL. Even though the Mem structure contains an element
     ** of type i64, on certain architectures (x86) with certain compiler
     ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
     ** instead of an 8-byte one. This all works fine, except that when
     ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
     ** that a Mem structure is located on an 8-byte boundary. To prevent
     ** these assert()s from failing, when building with SQLITE_DEBUG defined
     ** using gcc, we force nullMem to be 8-byte aligned using the magical
     ** __attribute__((aligned(8))) macro.  */
     static const Mem nullMem
 #if defined(SQLITE_DEBUG) && defined(__GNUC__)
       __attribute__((aligned(8)))
 #endif
       = {0, "", (double)0, {0}, 0, MEM_Null, SQLITE_NULL, 0,
 #ifdef SQLITE_DEBUG
 , 0,  /* pScopyFrom, pFiller */
 #endif
 , 0 };
     if( pVm && ALWAYS(pVm->db) ){
       sqlite3_mutex_enter(pVm->db->mutex);
       sqlite3Error(pVm->db, SQLITE_RANGE, 0);
     }
     pOut = (Mem*)&nullMem;
     pOut = (Mem*)columnNullValue();
   }
   return pOut;
 }

@@ -65132,7 +66514,7 @@ SQLITE_API int sqlite3_bind_text16(

 #endif /* SQLITE_OMIT_UTF16 */
 SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
   int rc;
   switch( pValue->type ){
   switch( sqlite3_value_type((sqlite3_value*)pValue) ){
     case SQLITE_INTEGER: {
       rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
       break;

@@ -65413,6 +66795,7 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(

       const char *zStart = zRawSql;
       while( *(zRawSql++)!='\n' && *zRawSql );
       sqlite3StrAccumAppend(&out, "-- ", 3);
       assert( (zRawSql - zStart) > 0 );
       sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
     }
   }else{

@@ -65445,9 +66828,9 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(

       if( pVar->flags & MEM_Null ){
         sqlite3StrAccumAppend(&out, "NULL", 4);
       }else if( pVar->flags & MEM_Int ){
         sqlite3XPrintf(&out, "%lld", pVar->u.i);
         sqlite3XPrintf(&out, 0, "%lld", pVar->u.i);
       }else if( pVar->flags & MEM_Real ){
         sqlite3XPrintf(&out, "%!.15g", pVar->r);
         sqlite3XPrintf(&out, 0, "%!.15g", pVar->r);
       }else if( pVar->flags & MEM_Str ){
         int nOut;  /* Number of bytes of the string text to include in output */
 #ifndef SQLITE_OMIT_UTF16

@@ -65468,15 +66851,17 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(

           while( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; }
         }
 #endif
         sqlite3XPrintf(&out, "'%.*q'", nOut, pVar->z);
         sqlite3XPrintf(&out, 0, "'%.*q'", nOut, pVar->z);
 #ifdef SQLITE_TRACE_SIZE_LIMIT
         if( nOut<pVar->n ) sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut);
         if( nOut<pVar->n ){
           sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut);
         }
 #endif
 #ifndef SQLITE_OMIT_UTF16
         if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8);
 #endif
       }else if( pVar->flags & MEM_Zero ){
         sqlite3XPrintf(&out, "zeroblob(%d)", pVar->u.nZero);
         sqlite3XPrintf(&out, 0, "zeroblob(%d)", pVar->u.nZero);
       }else{
         int nOut;  /* Number of bytes of the blob to include in output */
         assert( pVar->flags & MEM_Blob );

@@ -65486,11 +66871,13 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(

         if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT;
 #endif
         for(i=0; i<nOut; i++){
           sqlite3XPrintf(&out, "%02x", pVar->z[i]&0xff);
           sqlite3XPrintf(&out, 0, "%02x", pVar->z[i]&0xff);
         }
         sqlite3StrAccumAppend(&out, "'", 1);
 #ifdef SQLITE_TRACE_SIZE_LIMIT
         if( nOut<pVar->n ) sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut);
         if( nOut<pVar->n ){
           sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut);
         }
 #endif
       }
     }

@@ -65549,7 +66936,7 @@ SQLITE_PRIVATE void sqlite3ExplainPrintf(Vdbe *pVdbe, const char *zFormat, ...){

       sqlite3AppendSpace(&p->str, p->aIndent[n-1]);
     }
     va_start(ap, zFormat);
     sqlite3VXPrintf(&p->str, 1, zFormat, ap);
     sqlite3VXPrintf(&p->str, SQLITE_PRINTF_INTERNAL, zFormat, ap);
     va_end(ap);
   }
 }

@@ -65628,33 +67015,8 @@ SQLITE_PRIVATE const char *sqlite3VdbeExplanation(Vdbe *pVdbe){

 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 ** The code in this file implements execution method of the
 ** Virtual Database Engine (VDBE).  A separate file ("vdbeaux.c")
 ** handles housekeeping details such as creating and deleting
 ** VDBE instances.  This file is solely interested in executing
 ** the VDBE program.
 **
 ** In the external interface, an "sqlite3_stmt*" is an opaque pointer
 ** to a VDBE.
 **
 ** The SQL parser generates a program which is then executed by
 ** the VDBE to do the work of the SQL statement.  VDBE programs are
 ** similar in form to assembly language.  The program consists of
 ** a linear sequence of operations.  Each operation has an opcode
 ** and 5 operands.  Operands P1, P2, and P3 are integers.  Operand P4
 ** is a null-terminated string.  Operand P5 is an unsigned character.
 ** Few opcodes use all 5 operands.
 **
 ** Computation results are stored on a set of registers numbered beginning
 ** with 1 and going up to Vdbe.nMem.  Each register can store
 ** either an integer, a null-terminated string, a floating point
 ** number, or the SQL "NULL" value.  An implicit conversion from one
 ** type to the other occurs as necessary.
 **
 ** Most of the code in this file is taken up by the sqlite3VdbeExec()
 ** function which does the work of interpreting a VDBE program.
 ** But other routines are also provided to help in building up
 ** a program instruction by instruction.
 ** The code in this file implements the function that runs the
 ** bytecode of a prepared statement.
 **
 ** Various scripts scan this source file in order to generate HTML
 ** documentation, headers files, or other derived files.  The formatting

@@ -65666,7 +67028,11 @@ SQLITE_PRIVATE const char *sqlite3VdbeExplanation(Vdbe *pVdbe){

 /*
 ** Invoke this macro on memory cells just prior to changing the
 ** value of the cell.  This macro verifies that shallow copies are
 ** not misused.
 ** not misused.  A shallow copy of a string or blob just copies a
 ** pointer to the string or blob, not the content.  If the original
 ** is changed while the copy is still in use, the string or blob might
 ** be changed out from under the copy.  This macro verifies that nothing
 ** like that ever happens.
 */
 #ifdef SQLITE_DEBUG
 # define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M)

@@ -65725,7 +67091,7 @@ static void updateMaxBlobsize(Mem *p){

 #endif
 /*
 ** The next global variable is incremented each type the OP_Found opcode
 ** The next global variable is incremented each time the OP_Found opcode
 ** is executed. This is used to test whether or not the foreign key
 ** operation implemented using OP_FkIsZero is working. This variable
 ** has no function other than to help verify the correct operation of the

@@ -65746,6 +67112,34 @@ SQLITE_API int sqlite3_found_count = 0;

 #endif
 /*
 ** Invoke the VDBE coverage callback, if that callback is defined.  This
 ** feature is used for test suite validation only and does not appear an
 ** production builds.
 **
 ** M is an integer, 2 or 3, that indices how many different ways the
 ** branch can go.  It is usually 2.  "I" is the direction the branch
 ** goes.  0 means falls through.  1 means branch is taken.  2 means the
 ** second alternative branch is taken.
 */
 #if !defined(SQLITE_VDBE_COVERAGE)
 # define VdbeBranchTaken(I,M)
 #else
 # define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M)
   static void vdbeTakeBranch(int iSrcLine, u8 I, u8 M){
     if( iSrcLine<=2 && ALWAYS(iSrcLine>0) ){
       M = iSrcLine;
       /* Assert the truth of VdbeCoverageAlwaysTaken() and
       ** VdbeCoverageNeverTaken() */
       assert( (M & I)==I );
     }else{
       if( sqlite3GlobalConfig.xVdbeBranch==0 ) return;  /*NO_TEST*/
       sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg,
                                       iSrcLine,I,M);
     }
   }
 #endif
 /*
 ** Convert the given register into a string if it isn't one
 ** already. Return non-zero if a malloc() fails.
 */

@@ -65762,38 +67156,14 @@ SQLITE_API int sqlite3_found_count = 0;

 **
 ** This routine converts an ephemeral string into a dynamically allocated
 ** string that the register itself controls.  In other words, it
 ** converts an MEM_Ephem string into an MEM_Dyn string.
 ** converts an MEM_Ephem string into a string with P.z==P.zMalloc.
 */
 #define Deephemeralize(P) \
    if( ((P)->flags&MEM_Ephem)!=0 \
        && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
 /* Return true if the cursor was opened using the OP_OpenSorter opcode. */
 # define isSorter(x) ((x)->pSorter!=0)
 /*
 ** Argument pMem points at a register that will be passed to a
 ** user-defined function or returned to the user as the result of a query.
 ** This routine sets the pMem->type variable used by the sqlite3_value_*()
 ** routines.
 */
 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem){
   int flags = pMem->flags;
   if( flags & MEM_Null ){
     pMem->type = SQLITE_NULL;
   }
   else if( flags & MEM_Int ){
     pMem->type = SQLITE_INTEGER;
   }
   else if( flags & MEM_Real ){
     pMem->type = SQLITE_FLOAT;
   }
   else if( flags & MEM_Str ){
     pMem->type = SQLITE_TEXT;
   }else{
     pMem->type = SQLITE_BLOB;
   }
 }
 #define isSorter(x) ((x)->pSorter!=0)
 /*
 ** Allocate VdbeCursor number iCur.  Return a pointer to it.  Return NULL

@@ -65829,9 +67199,8 @@ static VdbeCursor *allocateCursor(

   int nByte;
   VdbeCursor *pCx = 0;
   nByte =
       ROUND8(sizeof(VdbeCursor)) +
       (isBtreeCursor?sqlite3BtreeCursorSize():0) +
 *nField*sizeof(u32);
       ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField +
       (isBtreeCursor?sqlite3BtreeCursorSize():0);
   assert( iCur<p->nCursor );
   if( p->apCsr[iCur] ){

@@ -65843,12 +67212,9 @@ static VdbeCursor *allocateCursor(

     memset(pCx, 0, sizeof(VdbeCursor));
     pCx->iDb = iDb;
     pCx->nField = nField;
     if( nField ){
       pCx->aType = (u32 *)&pMem->z[ROUND8(sizeof(VdbeCursor))];
     }
     if( isBtreeCursor ){
       pCx->pCursor = (BtCursor*)
           &pMem->z[ROUND8(sizeof(VdbeCursor))+2*nField*sizeof(u32)];
           &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
       sqlite3BtreeCursorZero(pCx->pCursor);
     }
   }

@@ -65927,12 +67293,13 @@ static void applyAffinity(

 ** loss of information and return the revised type of the argument.
 */
 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){
   Mem *pMem = (Mem*)pVal;
   if( pMem->type==SQLITE_TEXT ){
   int eType = sqlite3_value_type(pVal);
   if( eType==SQLITE_TEXT ){
     Mem *pMem = (Mem*)pVal;
     applyNumericAffinity(pMem);
     sqlite3VdbeMemStoreType(pMem);
     eType = sqlite3_value_type(pVal);
   }
   return pMem->type;
   return eType;
 }
 /*

@@ -66034,37 +67401,36 @@ SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){

 /*
 ** Print the value of a register for tracing purposes:
 */
 static void memTracePrint(FILE *out, Mem *p){
   if( p->flags & MEM_Invalid ){
     fprintf(out, " undefined");
 static void memTracePrint(Mem *p){
   if( p->flags & MEM_Undefined ){
     printf(" undefined");
   }else if( p->flags & MEM_Null ){
     fprintf(out, " NULL");
     printf(" NULL");
   }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
     fprintf(out, " si:%lld", p->u.i);
     printf(" si:%lld", p->u.i);
   }else if( p->flags & MEM_Int ){
     fprintf(out, " i:%lld", p->u.i);
     printf(" i:%lld", p->u.i);
 #ifndef SQLITE_OMIT_FLOATING_POINT
   }else if( p->flags & MEM_Real ){
     fprintf(out, " r:%g", p->r);
     printf(" r:%g", p->r);
 #endif
   }else if( p->flags & MEM_RowSet ){
     fprintf(out, " (rowset)");
     printf(" (rowset)");
   }else{
     char zBuf[200];
     sqlite3VdbeMemPrettyPrint(p, zBuf);
     fprintf(out, " ");
     fprintf(out, "%s", zBuf);
     printf(" %s", zBuf);
   }
 }
 static void registerTrace(FILE *out, int iReg, Mem *p){
   fprintf(out, "REG[%d] = ", iReg);
   memTracePrint(out, p);
   fprintf(out, "\n");
 static void registerTrace(int iReg, Mem *p){
   printf("REG[%d] = ", iReg);
   memTracePrint(p);
   printf("\n");
 }
 #endif
 #ifdef SQLITE_DEBUG
 #  define REGISTER_TRACE(R,M) if(p->trace)registerTrace(p->trace,R,M)
 #  define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M)
 #else
 #  define REGISTER_TRACE(R,M)
 #endif

@@ -66169,20 +67535,6 @@ SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }

 #endif
 /*
 ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
 ** sqlite3_interrupt() routine has been called.  If it has been, then
 ** processing of the VDBE program is interrupted.
 **
 ** This macro added to every instruction that does a jump in order to
 ** implement a loop.  This test used to be on every single instruction,
 ** but that meant we more testing than we needed.  By only testing the
 ** flag on jump instructions, we get a (small) speed improvement.
 */
 #define CHECK_FOR_INTERRUPT \
    if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
 #ifndef NDEBUG
 /*
 ** This function is only called from within an assert() expression. It

@@ -66205,35 +67557,8 @@ static int checkSavepointCount(sqlite3 *db){

 /*
 ** Execute as much of a VDBE program as we can then return.
 **
 ** sqlite3VdbeMakeReady() must be called before this routine in order to
 ** close the program with a final OP_Halt and to set up the callbacks
 ** and the error message pointer.
 **
 ** Whenever a row or result data is available, this routine will either
 ** invoke the result callback (if there is one) or return with
 ** SQLITE_ROW.
 **
 ** If an attempt is made to open a locked database, then this routine
 ** will either invoke the busy callback (if there is one) or it will
 ** return SQLITE_BUSY.
 **
 ** If an error occurs, an error message is written to memory obtained
 ** from sqlite3_malloc() and p->zErrMsg is made to point to that memory.
 ** The error code is stored in p->rc and this routine returns SQLITE_ERROR.
 **
 ** If the callback ever returns non-zero, then the program exits
 ** immediately.  There will be no error message but the p->rc field is
 ** set to SQLITE_ABORT and this routine will return SQLITE_ERROR.
 **
 ** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this
 ** routine to return SQLITE_ERROR.
 **
 ** Other fatal errors return SQLITE_ERROR.
 **
 ** After this routine has finished, sqlite3VdbeFinalize() should be
 ** used to clean up the mess that was left behind.
 ** Execute as much of a VDBE program as we can.
 ** This is the core of sqlite3_step().
 */
 SQLITE_PRIVATE int sqlite3VdbeExec(
   Vdbe *p                    /* The VDBE */

@@ -66259,438 +67584,8 @@ SQLITE_PRIVATE int sqlite3VdbeExec(

   i64 lastRowid = db->lastRowid;  /* Saved value of the last insert ROWID */
 #ifdef VDBE_PROFILE
   u64 start;                 /* CPU clock count at start of opcode */
   int origPc;                /* Program counter at start of opcode */
 #endif
   /********************************************************************
   ** Automatically generated code
   **
   ** The following union is automatically generated by the
   ** vdbe-compress.tcl script.  The purpose of this union is to
   ** reduce the amount of stack space required by this function.
   ** See comments in the vdbe-compress.tcl script for details.
   */
   union vdbeExecUnion {
     struct OP_Yield_stack_vars {
       int pcDest;
     } aa;
     struct OP_Null_stack_vars {
       int cnt;
       u16 nullFlag;
     } ab;
     struct OP_Variable_stack_vars {
       Mem *pVar;       /* Value being transferred */
     } ac;
     struct OP_Move_stack_vars {
       char *zMalloc;   /* Holding variable for allocated memory */
       int n;           /* Number of registers left to copy */
       int p1;          /* Register to copy from */
       int p2;          /* Register to copy to */
     } ad;
     struct OP_Copy_stack_vars {
       int n;
     } ae;
     struct OP_ResultRow_stack_vars {
       Mem *pMem;
       int i;
     } af;
     struct OP_Concat_stack_vars {
       i64 nByte;
     } ag;
     struct OP_Remainder_stack_vars {
       char bIntint;   /* Started out as two integer operands */
       int flags;      /* Combined MEM_* flags from both inputs */
       i64 iA;         /* Integer value of left operand */
       i64 iB;         /* Integer value of right operand */
       double rA;      /* Real value of left operand */
       double rB;      /* Real value of right operand */
     } ah;
     struct OP_Function_stack_vars {
       int i;
       Mem *pArg;
       sqlite3_context ctx;
       sqlite3_value **apVal;
       int n;
     } ai;
     struct OP_ShiftRight_stack_vars {
       i64 iA;
       u64 uA;
       i64 iB;
       u8 op;
     } aj;
     struct OP_Ge_stack_vars {
       int res;            /* Result of the comparison of pIn1 against pIn3 */
       char affinity;      /* Affinity to use for comparison */
       u16 flags1;         /* Copy of initial value of pIn1->flags */
       u16 flags3;         /* Copy of initial value of pIn3->flags */
     } ak;
     struct OP_Compare_stack_vars {
       int n;
       int i;
       int p1;
       int p2;
       const KeyInfo *pKeyInfo;
       int idx;
       CollSeq *pColl;    /* Collating sequence to use on this term */
       int bRev;          /* True for DESCENDING sort order */
     } al;
     struct OP_Or_stack_vars {
       int v1;    /* Left operand:  0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
       int v2;    /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
     } am;
     struct OP_IfNot_stack_vars {
       int c;
     } an;
     struct OP_Column_stack_vars {
       u32 payloadSize;   /* Number of bytes in the record */
       i64 payloadSize64; /* Number of bytes in the record */
       int p1;            /* P1 value of the opcode */
       int p2;            /* column number to retrieve */
       VdbeCursor *pC;    /* The VDBE cursor */
       char *zRec;        /* Pointer to complete record-data */
       BtCursor *pCrsr;   /* The BTree cursor */
       u32 *aType;        /* aType[i] holds the numeric type of the i-th column */
       u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
       int nField;        /* number of fields in the record */
       int len;           /* The length of the serialized data for the column */
       int i;             /* Loop counter */
       char *zData;       /* Part of the record being decoded */
       Mem *pDest;        /* Where to write the extracted value */
       Mem sMem;          /* For storing the record being decoded */
       u8 *zIdx;          /* Index into header */
       u8 *zEndHdr;       /* Pointer to first byte after the header */
       u32 offset;        /* Offset into the data */
       u32 szField;       /* Number of bytes in the content of a field */
       int szHdr;         /* Size of the header size field at start of record */
       int avail;         /* Number of bytes of available data */
       u32 t;             /* A type code from the record header */
       Mem *pReg;         /* PseudoTable input register */
     } ao;
     struct OP_Affinity_stack_vars {
       const char *zAffinity;   /* The affinity to be applied */
       char cAff;               /* A single character of affinity */
     } ap;
     struct OP_MakeRecord_stack_vars {
       u8 *zNewRecord;        /* A buffer to hold the data for the new record */
       Mem *pRec;             /* The new record */
       u64 nData;             /* Number of bytes of data space */
       int nHdr;              /* Number of bytes of header space */
       i64 nByte;             /* Data space required for this record */
       int nZero;             /* Number of zero bytes at the end of the record */
       int nVarint;           /* Number of bytes in a varint */
       u32 serial_type;       /* Type field */
       Mem *pData0;           /* First field to be combined into the record */
       Mem *pLast;            /* Last field of the record */
       int nField;            /* Number of fields in the record */
       char *zAffinity;       /* The affinity string for the record */
       int file_format;       /* File format to use for encoding */
       int i;                 /* Space used in zNewRecord[] */
       int len;               /* Length of a field */
     } aq;
     struct OP_Count_stack_vars {
       i64 nEntry;
       BtCursor *pCrsr;
     } ar;
     struct OP_Savepoint_stack_vars {
       int p1;                         /* Value of P1 operand */
       char *zName;                    /* Name of savepoint */
       int nName;
       Savepoint *pNew;
       Savepoint *pSavepoint;
       Savepoint *pTmp;
       int iSavepoint;
       int ii;
     } as;
     struct OP_AutoCommit_stack_vars {
       int desiredAutoCommit;
       int iRollback;
       int turnOnAC;
     } at;
     struct OP_Transaction_stack_vars {
       Btree *pBt;
     } au;
     struct OP_ReadCookie_stack_vars {
       int iMeta;
       int iDb;
       int iCookie;
     } av;
     struct OP_SetCookie_stack_vars {
       Db *pDb;
     } aw;
     struct OP_VerifyCookie_stack_vars {
       int iMeta;
       int iGen;
       Btree *pBt;
     } ax;
     struct OP_OpenWrite_stack_vars {
       int nField;
       KeyInfo *pKeyInfo;
       int p2;
       int iDb;
       int wrFlag;
       Btree *pX;
       VdbeCursor *pCur;
       Db *pDb;
     } ay;
     struct OP_OpenEphemeral_stack_vars {
       VdbeCursor *pCx;
     } az;
     struct OP_SorterOpen_stack_vars {
       VdbeCursor *pCx;
     } ba;
     struct OP_OpenPseudo_stack_vars {
       VdbeCursor *pCx;
     } bb;
     struct OP_SeekGt_stack_vars {
       int res;
       int oc;
       VdbeCursor *pC;
       UnpackedRecord r;
       int nField;
       i64 iKey;      /* The rowid we are to seek to */
     } bc;
     struct OP_Seek_stack_vars {
       VdbeCursor *pC;
     } bd;
     struct OP_Found_stack_vars {
       int alreadyExists;
       VdbeCursor *pC;
       int res;
       char *pFree;
       UnpackedRecord *pIdxKey;
       UnpackedRecord r;
       char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
     } be;
     struct OP_IsUnique_stack_vars {
       u16 ii;
       VdbeCursor *pCx;
       BtCursor *pCrsr;
       u16 nField;
       Mem *aMx;
       UnpackedRecord r;                  /* B-Tree index search key */
       i64 R;                             /* Rowid stored in register P3 */
     } bf;
     struct OP_NotExists_stack_vars {
       VdbeCursor *pC;
       BtCursor *pCrsr;
       int res;
       u64 iKey;
     } bg;
     struct OP_NewRowid_stack_vars {
       i64 v;                 /* The new rowid */
       VdbeCursor *pC;        /* Cursor of table to get the new rowid */
       int res;               /* Result of an sqlite3BtreeLast() */
       int cnt;               /* Counter to limit the number of searches */
       Mem *pMem;             /* Register holding largest rowid for AUTOINCREMENT */
       VdbeFrame *pFrame;     /* Root frame of VDBE */
     } bh;
     struct OP_InsertInt_stack_vars {
       Mem *pData;       /* MEM cell holding data for the record to be inserted */
       Mem *pKey;        /* MEM cell holding key  for the record */
       i64 iKey;         /* The integer ROWID or key for the record to be inserted */
       VdbeCursor *pC;   /* Cursor to table into which insert is written */
       int nZero;        /* Number of zero-bytes to append */
       int seekResult;   /* Result of prior seek or 0 if no USESEEKRESULT flag */
       const char *zDb;  /* database name - used by the update hook */
       const char *zTbl; /* Table name - used by the opdate hook */
       int op;           /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */
     } bi;
     struct OP_Delete_stack_vars {
       i64 iKey;
       VdbeCursor *pC;
     } bj;
     struct OP_SorterCompare_stack_vars {
       VdbeCursor *pC;
       int res;
     } bk;
     struct OP_SorterData_stack_vars {
       VdbeCursor *pC;
     } bl;
     struct OP_RowData_stack_vars {
       VdbeCursor *pC;
       BtCursor *pCrsr;
       u32 n;
       i64 n64;
     } bm;
     struct OP_Rowid_stack_vars {
       VdbeCursor *pC;
       i64 v;
       sqlite3_vtab *pVtab;
       const sqlite3_module *pModule;
     } bn;
     struct OP_NullRow_stack_vars {
       VdbeCursor *pC;
     } bo;
     struct OP_Last_stack_vars {
       VdbeCursor *pC;
       BtCursor *pCrsr;
       int res;
     } bp;
     struct OP_Rewind_stack_vars {
       VdbeCursor *pC;
       BtCursor *pCrsr;
       int res;
     } bq;
     struct OP_Next_stack_vars {
       VdbeCursor *pC;
       int res;
     } br;
     struct OP_IdxInsert_stack_vars {
       VdbeCursor *pC;
       BtCursor *pCrsr;
       int nKey;
       const char *zKey;
     } bs;
     struct OP_IdxDelete_stack_vars {
       VdbeCursor *pC;
       BtCursor *pCrsr;
       int res;
       UnpackedRecord r;
     } bt;
     struct OP_IdxRowid_stack_vars {
       BtCursor *pCrsr;
       VdbeCursor *pC;
       i64 rowid;
     } bu;
     struct OP_IdxGE_stack_vars {
       VdbeCursor *pC;
       int res;
       UnpackedRecord r;
     } bv;
     struct OP_Destroy_stack_vars {
       int iMoved;
       int iCnt;
       Vdbe *pVdbe;
       int iDb;
     } bw;
     struct OP_Clear_stack_vars {
       int nChange;
     } bx;
     struct OP_CreateTable_stack_vars {
       int pgno;
       int flags;
       Db *pDb;
     } by;
     struct OP_ParseSchema_stack_vars {
       int iDb;
       const char *zMaster;
       char *zSql;
       InitData initData;
     } bz;
     struct OP_IntegrityCk_stack_vars {
       int nRoot;      /* Number of tables to check.  (Number of root pages.) */
       int *aRoot;     /* Array of rootpage numbers for tables to be checked */
       int j;          /* Loop counter */
       int nErr;       /* Number of errors reported */
       char *z;        /* Text of the error report */
       Mem *pnErr;     /* Register keeping track of errors remaining */
     } ca;
     struct OP_RowSetRead_stack_vars {
       i64 val;
     } cb;
     struct OP_RowSetTest_stack_vars {
       int iSet;
       int exists;
     } cc;
     struct OP_Program_stack_vars {
       int nMem;               /* Number of memory registers for sub-program */
       int nByte;              /* Bytes of runtime space required for sub-program */
       Mem *pRt;               /* Register to allocate runtime space */
       Mem *pMem;              /* Used to iterate through memory cells */
       Mem *pEnd;              /* Last memory cell in new array */
       VdbeFrame *pFrame;      /* New vdbe frame to execute in */
       SubProgram *pProgram;   /* Sub-program to execute */
       void *t;                /* Token identifying trigger */
     } cd;
     struct OP_Param_stack_vars {
       VdbeFrame *pFrame;
       Mem *pIn;
     } ce;
     struct OP_MemMax_stack_vars {
       Mem *pIn1;
       VdbeFrame *pFrame;
     } cf;
     struct OP_AggStep_stack_vars {
       int n;
       int i;
       Mem *pMem;
       Mem *pRec;
       sqlite3_context ctx;
       sqlite3_value **apVal;
     } cg;
     struct OP_AggFinal_stack_vars {
       Mem *pMem;
     } ch;
     struct OP_Checkpoint_stack_vars {
       int i;                          /* Loop counter */
       int aRes[3];                    /* Results */
       Mem *pMem;                      /* Write results here */
     } ci;
     struct OP_JournalMode_stack_vars {
       Btree *pBt;                     /* Btree to change journal mode of */
       Pager *pPager;                  /* Pager associated with pBt */
       int eNew;                       /* New journal mode */
       int eOld;                       /* The old journal mode */
 #ifndef SQLITE_OMIT_WAL
       const char *zFilename;          /* Name of database file for pPager */
 #endif
     } cj;
     struct OP_IncrVacuum_stack_vars {
       Btree *pBt;
     } ck;
     struct OP_VBegin_stack_vars {
       VTable *pVTab;
     } cl;
     struct OP_VOpen_stack_vars {
       VdbeCursor *pCur;
       sqlite3_vtab_cursor *pVtabCursor;
       sqlite3_vtab *pVtab;
       sqlite3_module *pModule;
     } cm;
     struct OP_VFilter_stack_vars {
       int nArg;
       int iQuery;
       const sqlite3_module *pModule;
       Mem *pQuery;
       Mem *pArgc;
       sqlite3_vtab_cursor *pVtabCursor;
       sqlite3_vtab *pVtab;
       VdbeCursor *pCur;
       int res;
       int i;
       Mem **apArg;
     } cn;
     struct OP_VColumn_stack_vars {
       sqlite3_vtab *pVtab;
       const sqlite3_module *pModule;
       Mem *pDest;
       sqlite3_context sContext;
     } co;
     struct OP_VNext_stack_vars {
       sqlite3_vtab *pVtab;
       const sqlite3_module *pModule;
       int res;
       VdbeCursor *pCur;
     } cp;
     struct OP_VRename_stack_vars {
       sqlite3_vtab *pVtab;
       Mem *pName;
     } cq;
     struct OP_VUpdate_stack_vars {
       sqlite3_vtab *pVtab;
       sqlite3_module *pModule;
       int nArg;
       int i;
       sqlite_int64 rowid;
       Mem **apArg;
       Mem *pX;
     } cr;
     struct OP_Trace_stack_vars {
       char *zTrace;
       char *z;
     } cs;
   } u;
   /* End automatically generated code
   ********************************************************************/
   /*** INSERT STACK UNION HERE ***/
   assert( p->magic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */
   sqlite3VdbeEnter(p);

@@ -66706,7 +67601,7 @@ SQLITE_PRIVATE int sqlite3VdbeExec(

   assert( p->explain==0 );
   p->pResultSet = 0;
   db->busyHandler.nBusy = 0;
   CHECK_FOR_INTERRUPT;
   if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
   sqlite3VdbeIOTraceSql(p);
 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
   if( db->xProgress ){

@@ -66721,13 +67616,28 @@ SQLITE_PRIVATE int sqlite3VdbeExec(

 #endif
 #ifdef SQLITE_DEBUG
   sqlite3BeginBenignMalloc();
   if( p->pc==0  && (p->db->flags & SQLITE_VdbeListing)!=0 ){
   if( p->pc==0
    && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
   ){
     int i;
     printf("VDBE Program Listing:\n");
     int once = 1;
     sqlite3VdbePrintSql(p);
     for(i=0; i<p->nOp; i++){
       sqlite3VdbePrintOp(stdout, i, &aOp[i]);
     if( p->db->flags & SQLITE_VdbeListing ){
       printf("VDBE Program Listing:\n");
       for(i=0; i<p->nOp; i++){
         sqlite3VdbePrintOp(stdout, i, &aOp[i]);
       }
     }
     if( p->db->flags & SQLITE_VdbeEQP ){
       for(i=0; i<p->nOp; i++){
         if( aOp[i].opcode==OP_Explain ){
           if( once ) printf("VDBE Query Plan:\n");
           printf("%s\n", aOp[i].p4.z);
           once = 0;
         }
       }
     }
     if( p->db->flags & SQLITE_VdbeTrace )  printf("VDBE Trace:\n");
   }
   sqlite3EndBenignMalloc();
 #endif

@@ -66735,7 +67645,6 @@ SQLITE_PRIVATE int sqlite3VdbeExec(

     assert( pc>=0 && pc<p->nOp );
     if( db->mallocFailed ) goto no_mem;
 #ifdef VDBE_PROFILE
     origPc = pc;
     start = sqlite3Hwtime();
 #endif
     nVmStep++;

@@ -66744,12 +67653,8 @@ SQLITE_PRIVATE int sqlite3VdbeExec(

     /* Only allow tracing if SQLITE_DEBUG is defined.
     */
 #ifdef SQLITE_DEBUG
     if( p->trace ){
       if( pc==0 ){
         printf("VDBE Execution Trace:\n");
         sqlite3VdbePrintSql(p);
       }
       sqlite3VdbePrintOp(p->trace, pc, pOp);
     if( db->flags & SQLITE_VdbeTrace ){
       sqlite3VdbePrintOp(stdout, pc, pOp);
     }
 #endif

@@ -66787,18 +67692,21 @@ SQLITE_PRIVATE int sqlite3VdbeExec(

       assert( pOp->p1>0 );
       assert( pOp->p1<=(p->nMem-p->nCursor) );
       assert( memIsValid(&aMem[pOp->p1]) );
       assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
       REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
     }
     if( (pOp->opflags & OPFLG_IN2)!=0 ){
       assert( pOp->p2>0 );
       assert( pOp->p2<=(p->nMem-p->nCursor) );
       assert( memIsValid(&aMem[pOp->p2]) );
       assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
       REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
     }
     if( (pOp->opflags & OPFLG_IN3)!=0 ){
       assert( pOp->p3>0 );
       assert( pOp->p3<=(p->nMem-p->nCursor) );
       assert( memIsValid(&aMem[pOp->p3]) );
       assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
       REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
     }
     if( (pOp->opflags & OPFLG_OUT2)!=0 ){

@@ -66856,6 +67764,11 @@ SQLITE_PRIVATE int sqlite3VdbeExec(

 ** The next instruction executed will be
 ** the one at index P2 from the beginning of
 ** the program.
 **
 ** The P1 parameter is not actually used by this opcode.  However, it
 ** is sometimes set to 1 instead of 0 as a hint to the command-line shell
 ** that this Goto is the bottom of a loop and that the lines from P2 down
 ** to the current line should be indented for EXPLAIN output.
 */
 case OP_Goto: {             /* jump */
   pc = pOp->p2 - 1;

@@ -66871,7 +67784,7 @@ case OP_Goto: { /* jump */

   ** checks on every opcode.  This helps sqlite3_step() to run about 1.5%
   ** faster according to "valgrind --tool=cachegrind" */
 check_for_interrupt:
   CHECK_FOR_INTERRUPT;
   if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
   /* Call the progress callback if it is configured and the required number
   ** of VDBE ops have been executed (either since this invocation of

@@ -66880,15 +67793,12 @@ check_for_interrupt:

   ** a return code SQLITE_ABORT.
   */
   if( db->xProgress!=0 && nVmStep>=nProgressLimit ){
     int prc;
     prc = db->xProgress(db->pProgressArg);
     if( prc!=0 ){
     assert( db->nProgressOps!=0 );
     nProgressLimit = nVmStep + db->nProgressOps - (nVmStep%db->nProgressOps);
     if( db->xProgress(db->pProgressArg) ){
       rc = SQLITE_INTERRUPT;
       goto vdbe_error_halt;
     }
     if( db->xProgress!=0 ){
       nProgressLimit = nVmStep + db->nProgressOps - (nVmStep%db->nProgressOps);
     }
   }
 #endif

@@ -66903,7 +67813,7 @@ check_for_interrupt:

 case OP_Gosub: {            /* jump */
   assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
   pIn1 = &aMem[pOp->p1];
   assert( (pIn1->flags & MEM_Dyn)==0 );
   assert( VdbeMemDynamic(pIn1)==0 );
   memAboutToChange(p, pIn1);
   pIn1->flags = MEM_Int;
   pIn1->u.i = pc;

@@ -66914,38 +67824,84 @@ case OP_Gosub: { /* jump */

 /* Opcode:  Return P1 * * * *
 **
 ** Jump to the next instruction after the address in register P1.
 ** Jump to the next instruction after the address in register P1.  After
 ** the jump, register P1 becomes undefined.
 */
 case OP_Return: {           /* in1 */
   pIn1 = &aMem[pOp->p1];
   assert( pIn1->flags & MEM_Int );
   assert( pIn1->flags==MEM_Int );
   pc = (int)pIn1->u.i;
   pIn1->flags = MEM_Undefined;
   break;
 }
 /* Opcode: InitCoroutine P1 P2 P3 * *
 **
 ** Set up register P1 so that it will OP_Yield to the co-routine
 ** located at address P3.
 **
 ** If P2!=0 then the co-routine implementation immediately follows
 ** this opcode.  So jump over the co-routine implementation to
 ** address P2.
 */
 case OP_InitCoroutine: {     /* jump */
   assert( pOp->p1>0 &&  pOp->p1<=(p->nMem-p->nCursor) );
   assert( pOp->p2>=0 && pOp->p2<p->nOp );
   assert( pOp->p3>=0 && pOp->p3<p->nOp );
   pOut = &aMem[pOp->p1];
   assert( !VdbeMemDynamic(pOut) );
   pOut->u.i = pOp->p3 - 1;
   pOut->flags = MEM_Int;
   if( pOp->p2 ) pc = pOp->p2 - 1;
   break;
 }
 /* Opcode:  Yield P1 * * * *
 /* Opcode:  EndCoroutine P1 * * * *
 **
 ** The instruction at the address in register P1 is an OP_Yield.
 ** Jump to the P2 parameter of that OP_Yield.
 ** After the jump, register P1 becomes undefined.
 */
 case OP_EndCoroutine: {           /* in1 */
   VdbeOp *pCaller;
   pIn1 = &aMem[pOp->p1];
   assert( pIn1->flags==MEM_Int );
   assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
   pCaller = &aOp[pIn1->u.i];
   assert( pCaller->opcode==OP_Yield );
   assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
   pc = pCaller->p2 - 1;
   pIn1->flags = MEM_Undefined;
   break;
 }
 /* Opcode:  Yield P1 P2 * * *
 **
 ** Swap the program counter with the value in register P1.
 **
 ** If the co-routine ends with OP_Yield or OP_Return then continue
 ** to the next instruction.  But if the co-routine ends with
 ** OP_EndCoroutine, jump immediately to P2.
 */
 case OP_Yield: {            /* in1 */
 #if 0  /* local variables moved into u.aa */
 case OP_Yield: {            /* in1, jump */
   int pcDest;
 #endif /* local variables moved into u.aa */
   pIn1 = &aMem[pOp->p1];
   assert( (pIn1->flags & MEM_Dyn)==0 );
   assert( VdbeMemDynamic(pIn1)==0 );
   pIn1->flags = MEM_Int;
   u.aa.pcDest = (int)pIn1->u.i;
   pcDest = (int)pIn1->u.i;
   pIn1->u.i = pc;
   REGISTER_TRACE(pOp->p1, pIn1);
   pc = u.aa.pcDest;
   pc = pcDest;
   break;
 }
 /* Opcode:  HaltIfNull  P1 P2 P3 P4 *
 /* Opcode:  HaltIfNull  P1 P2 P3 P4 P5
 ** Synopsis:  if r[P3]=null halt
 **
 ** Check the value in register P3.  If it is NULL then Halt using
 ** parameter P1, P2, and P4 as if this were a Halt instruction.  If the
 ** value in register P3 is not NULL, then this routine is a no-op.
 ** The P5 parameter should be 1.
 */
 case OP_HaltIfNull: {      /* in3 */
   pIn3 = &aMem[pOp->p3];

@@ -66953,7 +67909,7 @@ case OP_HaltIfNull: { /* in3 */

   /* Fall through into OP_Halt */
 }
 /* Opcode:  Halt P1 P2 * P4 *
 /* Opcode:  Halt P1 P2 * P4 P5
 **
 ** Exit immediately.  All open cursors, etc are closed
 ** automatically.

@@ -66968,11 +67924,25 @@ case OP_HaltIfNull: { /* in3 */

 **
 ** If P4 is not null then it is an error message string.
 **
 ** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
 **
 **    0:  (no change)
 **    1:  NOT NULL contraint failed: P4
 **    2:  UNIQUE constraint failed: P4
 **    3:  CHECK constraint failed: P4
 **    4:  FOREIGN KEY constraint failed: P4
 **
 ** If P5 is not zero and P4 is NULL, then everything after the ":" is
 ** omitted.
 **
 ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
 ** every program.  So a jump past the last instruction of the program
 ** is the same as executing Halt.
 */
 case OP_Halt: {
   const char *zType;
   const char *zLogFmt;
   if( pOp->p1==SQLITE_OK && p->pFrame ){
     /* Halt the sub-program. Return control to the parent frame. */
     VdbeFrame *pFrame = p->pFrame;

@@ -66993,18 +67963,33 @@ case OP_Halt: {

     aMem = p->aMem;
     break;
   }
   p->rc = pOp->p1;
   p->errorAction = (u8)pOp->p2;
   p->pc = pc;
   if( pOp->p4.z ){
     assert( p->rc!=SQLITE_OK );
     sqlite3SetString(&p->zErrMsg, db, "%s", pOp->p4.z);
     testcase( sqlite3GlobalConfig.xLog!=0 );
     sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pc, p->zSql, pOp->p4.z);
   }else if( p->rc ){
     testcase( sqlite3GlobalConfig.xLog!=0 );
     sqlite3_log(pOp->p1, "constraint failed at %d in [%s]", pc, p->zSql);
   if( p->rc ){
     if( pOp->p5 ){
       static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK",
                                              "FOREIGN KEY" };
       assert( pOp->p5>=1 && pOp->p5<=4 );
       testcase( pOp->p5==1 );
       testcase( pOp->p5==2 );
       testcase( pOp->p5==3 );
       testcase( pOp->p5==4 );
       zType = azType[pOp->p5-1];
     }else{
       zType = 0;
     }
     assert( zType!=0 || pOp->p4.z!=0 );
     zLogFmt = "abort at %d in [%s]: %s";
     if( zType && pOp->p4.z ){
       sqlite3SetString(&p->zErrMsg, db, "%s constraint failed: %s",
                        zType, pOp->p4.z);
     }else if( pOp->p4.z ){
       sqlite3SetString(&p->zErrMsg, db, "%s", pOp->p4.z);
     }else{
       sqlite3SetString(&p->zErrMsg, db, "%s constraint failed", zType);
     }
     sqlite3_log(pOp->p1, zLogFmt, pc, p->zSql, p->zErrMsg);
   }
   rc = sqlite3VdbeHalt(p);
   assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );

@@ -67019,6 +68004,7 @@ case OP_Halt: {

 }
 /* Opcode: Integer P1 P2 * * *
 ** Synopsis: r[P2]=P1
 **
 ** The 32-bit integer value P1 is written into register P2.
 */

@@ -67028,6 +68014,7 @@ case OP_Integer: { /* out2-prerelease */

 }
 /* Opcode: Int64 * P2 * P4 *
 ** Synopsis: r[P2]=P4
 **
 ** P4 is a pointer to a 64-bit integer value.
 ** Write that value into register P2.

@@ -67040,6 +68027,7 @@ case OP_Int64: { /* out2-prerelease */

 #ifndef SQLITE_OMIT_FLOATING_POINT
 /* Opcode: Real * P2 * P4 *
 ** Synopsis: r[P2]=P4
 **
 ** P4 is a pointer to a 64-bit floating point value.
 ** Write that value into register P2.

@@ -67053,9 +68041,12 @@ case OP_Real: { /* same as TK_FLOAT, out2-prerelease */

 #endif
 /* Opcode: String8 * P2 * P4 *
 ** Synopsis: r[P2]='P4'
 **
 ** P4 points to a nul terminated UTF-8 string. This opcode is transformed
 ** into an OP_String before it is executed for the first time.
 ** into an OP_String before it is executed for the first time.  During
 ** this transformation, the length of string P4 is computed and stored
 ** as the P1 parameter.
 */
 case OP_String8: {         /* same as TK_STRING, out2-prerelease */
   assert( pOp->p4.z!=0 );

@@ -67068,10 +68059,9 @@ case OP_String8: { /* same as TK_STRING, out2-prerelease */

     if( rc==SQLITE_TOOBIG ) goto too_big;
     if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
     assert( pOut->zMalloc==pOut->z );
     assert( pOut->flags & MEM_Dyn );
     assert( VdbeMemDynamic(pOut)==0 );
     pOut->zMalloc = 0;
     pOut->flags |= MEM_Static;
     pOut->flags &= ~MEM_Dyn;
     if( pOp->p4type==P4_DYNAMIC ){
       sqlite3DbFree(db, pOp->p4.z);
     }

@@ -67087,6 +68077,7 @@ case OP_String8: { /* same as TK_STRING, out2-prerelease */

 }
 /* Opcode: String P1 P2 * P4 *
 ** Synopsis: r[P2]='P4' (len=P1)
 **
 ** The string value P4 of length P1 (bytes) is stored in register P2.
 */

@@ -67101,6 +68092,7 @@ case OP_String: { /* out2-prerelease */

 }
 /* Opcode: Null P1 P2 P3 * *
 ** Synopsis:  r[P2..P3]=NULL
 **
 ** Write a NULL into registers P2.  If P3 greater than P2, then also write
 ** NULL into register P3 and every register in between P2 and P3.  If P3

@@ -67112,25 +68104,38 @@ case OP_String: { /* out2-prerelease */

 ** OP_Ne or OP_Eq.
 */
 case OP_Null: {           /* out2-prerelease */
 #if 0  /* local variables moved into u.ab */
   int cnt;
   u16 nullFlag;
 #endif /* local variables moved into u.ab */
   u.ab.cnt = pOp->p3-pOp->p2;
   cnt = pOp->p3-pOp->p2;
   assert( pOp->p3<=(p->nMem-p->nCursor) );
   pOut->flags = u.ab.nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
   while( u.ab.cnt>0 ){
   pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
   while( cnt>0 ){
     pOut++;
     memAboutToChange(p, pOut);
     VdbeMemRelease(pOut);
     pOut->flags = u.ab.nullFlag;
     u.ab.cnt--;
     pOut->flags = nullFlag;
     cnt--;
   }
   break;
 }
 /* Opcode: SoftNull P1 * * * *
 ** Synopsis:  r[P1]=NULL
 **
 ** Set register P1 to have the value NULL as seen by the OP_MakeRecord
 ** instruction, but do not free any string or blob memory associated with
 ** the register, so that if the value was a string or blob that was
 ** previously copied using OP_SCopy, the copies will continue to be valid.
 */
 case OP_SoftNull: {
   assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
   pOut = &aMem[pOp->p1];
   pOut->flags = (pOut->flags|MEM_Null)&~MEM_Undefined;
   break;
 }
 /* Opcode: Blob P1 P2 * P4
 /* Opcode: Blob P1 P2 * P4 *
 ** Synopsis: r[P2]=P4 (len=P1)
 **
 ** P4 points to a blob of data P1 bytes long.  Store this
 ** blob in register P2.

@@ -67144,29 +68149,29 @@ case OP_Blob: { /* out2-prerelease */

 }
 /* Opcode: Variable P1 P2 * P4 *
 ** Synopsis: r[P2]=parameter(P1,P4)
 **
 ** Transfer the values of bound parameter P1 into register P2
 **
 ** If the parameter is named, then its name appears in P4 and P3==1.
 ** If the parameter is named, then its name appears in P4.
 ** The P4 value is used by sqlite3_bind_parameter_name().
 */
 case OP_Variable: {            /* out2-prerelease */
 #if 0  /* local variables moved into u.ac */
   Mem *pVar;       /* Value being transferred */
 #endif /* local variables moved into u.ac */
   assert( pOp->p1>0 && pOp->p1<=p->nVar );
   assert( pOp->p4.z==0 || pOp->p4.z==p->azVar[pOp->p1-1] );
   u.ac.pVar = &p->aVar[pOp->p1 - 1];
   if( sqlite3VdbeMemTooBig(u.ac.pVar) ){
   pVar = &p->aVar[pOp->p1 - 1];
   if( sqlite3VdbeMemTooBig(pVar) ){
     goto too_big;
   }
   sqlite3VdbeMemShallowCopy(pOut, u.ac.pVar, MEM_Static);
   sqlite3VdbeMemShallowCopy(pOut, pVar, MEM_Static);
   UPDATE_MAX_BLOBSIZE(pOut);
   break;
 }
 /* Opcode: Move P1 P2 P3 * *
 ** Synopsis:  r[P2@P3]=r[P1@P3]
 **
 ** Move the values in register P1..P1+P3 over into
 ** registers P2..P2+P3.  Registers P1..P1+P3 are

@@ -67174,43 +68179,44 @@ case OP_Variable: { /* out2-prerelease */

 ** P1..P1+P3 and P2..P2+P3 to overlap.
 */
 case OP_Move: {
 #if 0  /* local variables moved into u.ad */
   char *zMalloc;   /* Holding variable for allocated memory */
   int n;           /* Number of registers left to copy */
   int p1;          /* Register to copy from */
   int p2;          /* Register to copy to */
 #endif /* local variables moved into u.ad */
   u.ad.n = pOp->p3 + 1;
   u.ad.p1 = pOp->p1;
   u.ad.p2 = pOp->p2;
   assert( u.ad.n>0 && u.ad.p1>0 && u.ad.p2>0 );
   assert( u.ad.p1+u.ad.n<=u.ad.p2 || u.ad.p2+u.ad.n<=u.ad.p1 );
   n = pOp->p3;
   p1 = pOp->p1;
   p2 = pOp->p2;
   assert( n>=0 && p1>0 && p2>0 );
   assert( p1+n<=p2 || p2+n<=p1 );
   pIn1 = &aMem[u.ad.p1];
   pOut = &aMem[u.ad.p2];
   while( u.ad.n-- ){
   pIn1 = &aMem[p1];
   pOut = &aMem[p2];
   do{
     assert( pOut<=&aMem[(p->nMem-p->nCursor)] );
     assert( pIn1<=&aMem[(p->nMem-p->nCursor)] );
     assert( memIsValid(pIn1) );
     memAboutToChange(p, pOut);
     u.ad.zMalloc = pOut->zMalloc;
     pOut->zMalloc = 0;
     sqlite3VdbeMemMove(pOut, pIn1);
     VdbeMemRelease(pOut);
     zMalloc = pOut->zMalloc;
     memcpy(pOut, pIn1, sizeof(Mem));
 #ifdef SQLITE_DEBUG
     if( pOut->pScopyFrom>=&aMem[u.ad.p1] && pOut->pScopyFrom<&aMem[u.ad.p1+pOp->p3] ){
       pOut->pScopyFrom += u.ad.p1 - pOp->p2;
     if( pOut->pScopyFrom>=&aMem[p1] && pOut->pScopyFrom<&aMem[p1+pOp->p3] ){
       pOut->pScopyFrom += p1 - pOp->p2;
     }
 #endif
     pIn1->zMalloc = u.ad.zMalloc;
     REGISTER_TRACE(u.ad.p2++, pOut);
     pIn1->flags = MEM_Undefined;
     pIn1->xDel = 0;
     pIn1->zMalloc = zMalloc;
     REGISTER_TRACE(p2++, pOut);
     pIn1++;
     pOut++;
   }
   }while( n-- );
   break;
 }
 /* Opcode: Copy P1 P2 P3 * *
 ** Synopsis: r[P2@P3+1]=r[P1@P3+1]
 **
 ** Make a copy of registers P1..P1+P3 into registers P2..P2+P3.
 **

@@ -67218,11 +68224,9 @@ case OP_Move: {

 ** is made of any string or blob constant.  See also OP_SCopy.
 */
 case OP_Copy: {
 #if 0  /* local variables moved into u.ae */
   int n;
 #endif /* local variables moved into u.ae */
   u.ae.n = pOp->p3;
   n = pOp->p3;
   pIn1 = &aMem[pOp->p1];
   pOut = &aMem[pOp->p2];
   assert( pOut!=pIn1 );

@@ -67232,8 +68236,8 @@ case OP_Copy: {

 #ifdef SQLITE_DEBUG
     pOut->pScopyFrom = 0;
 #endif
     REGISTER_TRACE(pOp->p2+pOp->p3-u.ae.n, pOut);
     if( (u.ae.n--)==0 ) break;
     REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
     if( (n--)==0 ) break;
     pOut++;
     pIn1++;
   }

@@ -67241,6 +68245,7 @@ case OP_Copy: {

 }
 /* Opcode: SCopy P1 P2 * * *
 ** Synopsis: r[P2]=r[P1]
 **
 ** Make a shallow copy of register P1 into register P2.
 **

@@ -67252,7 +68257,7 @@ case OP_Copy: {

 ** during the lifetime of the copy.  Use OP_Copy to make a complete
 ** copy.
 */
 case OP_SCopy: {            /* in1, out2 */
 case OP_SCopy: {            /* out2 */
   pIn1 = &aMem[pOp->p1];
   pOut = &aMem[pOp->p2];
   assert( pOut!=pIn1 );

@@ -67260,27 +68265,37 @@ case OP_SCopy: { /* in1, out2 */

 #ifdef SQLITE_DEBUG
   if( pOut->pScopyFrom==0 ) pOut->pScopyFrom = pIn1;
 #endif
   REGISTER_TRACE(pOp->p2, pOut);
   break;
 }
 /* Opcode: ResultRow P1 P2 * * *
 ** Synopsis:  output=r[P1@P2]
 **
 ** The registers P1 through P1+P2-1 contain a single row of
 ** results. This opcode causes the sqlite3_step() call to terminate
 ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
 ** structure to provide access to the top P1 values as the result
 ** row.
 ** structure to provide access to the r(P1)..r(P1+P2-1) values as
 ** the result row.
 */
 case OP_ResultRow: {
 #if 0  /* local variables moved into u.af */
   Mem *pMem;
   int i;
 #endif /* local variables moved into u.af */
   assert( p->nResColumn==pOp->p2 );
   assert( pOp->p1>0 );
   assert( pOp->p1+pOp->p2<=(p->nMem-p->nCursor)+1 );
 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
   /* Run the progress counter just before returning.
   */
   if( db->xProgress!=0
    && nVmStep>=nProgressLimit
    && db->xProgress(db->pProgressArg)!=0
   ){
     rc = SQLITE_INTERRUPT;
     goto vdbe_error_halt;
   }
 #endif
   /* If this statement has violated immediate foreign key constraints, do
   ** not return the number of rows modified. And do not RELEASE the statement
   ** transaction. It needs to be rolled back.  */

@@ -67290,8 +68305,8 @@ case OP_ResultRow: {

     break;
   }
   /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
   ** DML statements invoke this opcode to return the number of rows
   /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
   ** DML statements invoke this opcode to return the number of rows
   ** modified to the user. This is the only way that a VM that
   ** opens a statement transaction may invoke this opcode.
   **

@@ -67318,15 +68333,14 @@ case OP_ResultRow: {

   ** and have an assigned type.  The results are de-ephemeralized as
   ** a side effect.
   */
   u.af.pMem = p->pResultSet = &aMem[pOp->p1];
   for(u.af.i=0; u.af.i<pOp->p2; u.af.i++){
     assert( memIsValid(&u.af.pMem[u.af.i]) );
     Deephemeralize(&u.af.pMem[u.af.i]);
     assert( (u.af.pMem[u.af.i].flags & MEM_Ephem)==0
             || (u.af.pMem[u.af.i].flags & (MEM_Str|MEM_Blob))==0 );
     sqlite3VdbeMemNulTerminate(&u.af.pMem[u.af.i]);
     sqlite3VdbeMemStoreType(&u.af.pMem[u.af.i]);
     REGISTER_TRACE(pOp->p1+u.af.i, &u.af.pMem[u.af.i]);
   pMem = p->pResultSet = &aMem[pOp->p1];
   for(i=0; i<pOp->p2; i++){
     assert( memIsValid(&pMem[i]) );
     Deephemeralize(&pMem[i]);
     assert( (pMem[i].flags & MEM_Ephem)==0
             || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 );
     sqlite3VdbeMemNulTerminate(&pMem[i]);
     REGISTER_TRACE(pOp->p1+i, &pMem[i]);
   }
   if( db->mallocFailed ) goto no_mem;

@@ -67338,6 +68352,7 @@ case OP_ResultRow: {

 }
 /* Opcode: Concat P1 P2 P3 * *
 ** Synopsis: r[P3]=r[P2]+r[P1]
 **
 ** Add the text in register P1 onto the end of the text in
 ** register P2 and store the result in register P3.

@@ -67350,9 +68365,7 @@ case OP_ResultRow: {

 ** to avoid a memcpy().
 */
 case OP_Concat: {           /* same as TK_CONCAT, in1, in2, out3 */
 #if 0  /* local variables moved into u.ag */
   i64 nByte;
 #endif /* local variables moved into u.ag */
   pIn1 = &aMem[pOp->p1];
   pIn2 = &aMem[pOp->p2];

@@ -67365,34 +68378,36 @@ case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */

   if( ExpandBlob(pIn1) || ExpandBlob(pIn2) ) goto no_mem;
   Stringify(pIn1, encoding);
   Stringify(pIn2, encoding);
   u.ag.nByte = pIn1->n + pIn2->n;
   if( u.ag.nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
   nByte = pIn1->n + pIn2->n;
   if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
     goto too_big;
   }
   MemSetTypeFlag(pOut, MEM_Str);
   if( sqlite3VdbeMemGrow(pOut, (int)u.ag.nByte+2, pOut==pIn2) ){
   if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){
     goto no_mem;
   }
   MemSetTypeFlag(pOut, MEM_Str);
   if( pOut!=pIn2 ){
     memcpy(pOut->z, pIn2->z, pIn2->n);
   }
   memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
   pOut->z[u.ag.nByte] = 0;
   pOut->z[u.ag.nByte+1] = 0;
   pOut->z[nByte]=0;
   pOut->z[nByte+1] = 0;
   pOut->flags |= MEM_Term;
   pOut->n = (int)u.ag.nByte;
   pOut->n = (int)nByte;
   pOut->enc = encoding;
   UPDATE_MAX_BLOBSIZE(pOut);
   break;
 }
 /* Opcode: Add P1 P2 P3 * *
 ** Synopsis:  r[P3]=r[P1]+r[P2]
 **
 ** Add the value in register P1 to the value in register P2
 ** and store the result in register P3.
 ** If either input is NULL, the result is NULL.
 */
 /* Opcode: Multiply P1 P2 P3 * *
 ** Synopsis:  r[P3]=r[P1]*r[P2]
 **
 **
 ** Multiply the value in register P1 by the value in register P2

@@ -67400,12 +68415,14 @@ case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */

 ** If either input is NULL, the result is NULL.
 */
 /* Opcode: Subtract P1 P2 P3 * *
 ** Synopsis:  r[P3]=r[P2]-r[P1]
 **
 ** Subtract the value in register P1 from the value in register P2
 ** and store the result in register P3.
 ** If either input is NULL, the result is NULL.
 */
 /* Opcode: Divide P1 P2 P3 * *
 ** Synopsis:  r[P3]=r[P2]/r[P1]
 **
 ** Divide the value in register P1 by the value in register P2
 ** and store the result in register P3 (P3=P2/P1). If the value in

@@ -67413,10 +68430,11 @@ case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */

 ** NULL, the result is NULL.
 */
 /* Opcode: Remainder P1 P2 P3 * *
 ** Synopsis:  r[P3]=r[P2]%r[P1]
 **
 ** Compute the remainder after integer division of the value in
 ** register P1 by the value in register P2 and store the result in P3.
 ** If the value in register P2 is zero the result is NULL.
 ** Compute the remainder after integer register P2 is divided by
 ** register P1 and store the result in register P3.
 ** If the value in register P1 is zero the result is NULL.
 ** If either operand is NULL, the result is NULL.
 */
 case OP_Add:                   /* same as TK_PLUS, in1, in2, out3 */

@@ -67424,79 +68442,77 @@ case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */

 case OP_Multiply:              /* same as TK_STAR, in1, in2, out3 */
 case OP_Divide:                /* same as TK_SLASH, in1, in2, out3 */
 case OP_Remainder: {           /* same as TK_REM, in1, in2, out3 */
 #if 0  /* local variables moved into u.ah */
   char bIntint;   /* Started out as two integer operands */
   int flags;      /* Combined MEM_* flags from both inputs */
   i64 iA;         /* Integer value of left operand */
   i64 iB;         /* Integer value of right operand */
   double rA;      /* Real value of left operand */
   double rB;      /* Real value of right operand */
 #endif /* local variables moved into u.ah */
   pIn1 = &aMem[pOp->p1];
   applyNumericAffinity(pIn1);
   pIn2 = &aMem[pOp->p2];
   applyNumericAffinity(pIn2);
   pOut = &aMem[pOp->p3];
   u.ah.flags = pIn1->flags | pIn2->flags;
   if( (u.ah.flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;
   flags = pIn1->flags | pIn2->flags;
   if( (flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;
   if( (pIn1->flags & pIn2->flags & MEM_Int)==MEM_Int ){
     u.ah.iA = pIn1->u.i;
     u.ah.iB = pIn2->u.i;
     u.ah.bIntint = 1;
     iA = pIn1->u.i;
     iB = pIn2->u.i;
     bIntint = 1;
     switch( pOp->opcode ){
       case OP_Add:       if( sqlite3AddInt64(&u.ah.iB,u.ah.iA) ) goto fp_math;  break;
       case OP_Subtract:  if( sqlite3SubInt64(&u.ah.iB,u.ah.iA) ) goto fp_math;  break;
       case OP_Multiply:  if( sqlite3MulInt64(&u.ah.iB,u.ah.iA) ) goto fp_math;  break;
       case OP_Add:       if( sqlite3AddInt64(&iB,iA) ) goto fp_math;  break;
       case OP_Subtract:  if( sqlite3SubInt64(&iB,iA) ) goto fp_math;  break;
       case OP_Multiply:  if( sqlite3MulInt64(&iB,iA) ) goto fp_math;  break;
       case OP_Divide: {
         if( u.ah.iA==0 ) goto arithmetic_result_is_null;
         if( u.ah.iA==-1 && u.ah.iB==SMALLEST_INT64 ) goto fp_math;
         u.ah.iB /= u.ah.iA;
         if( iA==0 ) goto arithmetic_result_is_null;
         if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math;
         iB /= iA;
         break;
       }
       default: {
         if( u.ah.iA==0 ) goto arithmetic_result_is_null;
         if( u.ah.iA==-1 ) u.ah.iA = 1;
         u.ah.iB %= u.ah.iA;
         if( iA==0 ) goto arithmetic_result_is_null;
         if( iA==-1 ) iA = 1;
         iB %= iA;
         break;
       }
     }
     pOut->u.i = u.ah.iB;
     pOut->u.i = iB;
     MemSetTypeFlag(pOut, MEM_Int);
   }else{
     u.ah.bIntint = 0;
     bIntint = 0;
 fp_math:
     u.ah.rA = sqlite3VdbeRealValue(pIn1);
     u.ah.rB = sqlite3VdbeRealValue(pIn2);
     rA = sqlite3VdbeRealValue(pIn1);
     rB = sqlite3VdbeRealValue(pIn2);
     switch( pOp->opcode ){
       case OP_Add:         u.ah.rB += u.ah.rA;       break;
       case OP_Subtract:    u.ah.rB -= u.ah.rA;       break;
       case OP_Multiply:    u.ah.rB *= u.ah.rA;       break;
       case OP_Add:         rB += rA;       break;
       case OP_Subtract:    rB -= rA;       break;
       case OP_Multiply:    rB *= rA;       break;
       case OP_Divide: {
         /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
         if( u.ah.rA==(double)0 ) goto arithmetic_result_is_null;
         u.ah.rB /= u.ah.rA;
         if( rA==(double)0 ) goto arithmetic_result_is_null;
         rB /= rA;
         break;
       }
       default: {
         u.ah.iA = (i64)u.ah.rA;
         u.ah.iB = (i64)u.ah.rB;
         if( u.ah.iA==0 ) goto arithmetic_result_is_null;
         if( u.ah.iA==-1 ) u.ah.iA = 1;
         u.ah.rB = (double)(u.ah.iB % u.ah.iA);
         iA = (i64)rA;
         iB = (i64)rB;
         if( iA==0 ) goto arithmetic_result_is_null;
         if( iA==-1 ) iA = 1;
         rB = (double)(iB % iA);
         break;
       }
     }
 #ifdef SQLITE_OMIT_FLOATING_POINT
     pOut->u.i = u.ah.rB;
     pOut->u.i = rB;
     MemSetTypeFlag(pOut, MEM_Int);
 #else
     if( sqlite3IsNaN(u.ah.rB) ){
     if( sqlite3IsNaN(rB) ){
       goto arithmetic_result_is_null;
     }
     pOut->r = u.ah.rB;
     pOut->r = rB;
     MemSetTypeFlag(pOut, MEM_Real);
     if( (u.ah.flags & MEM_Real)==0 && !u.ah.bIntint ){
     if( (flags & MEM_Real)==0 && !bIntint ){
       sqlite3VdbeIntegerAffinity(pOut);
     }
 #endif

@@ -67532,6 +68548,7 @@ case OP_CollSeq: {

 }
 /* Opcode: Function P1 P2 P3 P4 P5
 ** Synopsis: r[P3]=func(r[P2@P5])
 **
 ** Invoke a user function (P4 is a pointer to a Function structure that
 ** defines the function) with P5 arguments taken from register P2 and

@@ -67548,57 +68565,53 @@ case OP_CollSeq: {

 ** See also: AggStep and AggFinal
 */
 case OP_Function: {
 #if 0  /* local variables moved into u.ai */
   int i;
   Mem *pArg;
   sqlite3_context ctx;
   sqlite3_value **apVal;
   int n;
 #endif /* local variables moved into u.ai */
   u.ai.n = pOp->p5;
   u.ai.apVal = p->apArg;
   assert( u.ai.apVal || u.ai.n==0 );
   n = pOp->p5;
   apVal = p->apArg;
   assert( apVal || n==0 );
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   pOut = &aMem[pOp->p3];
   memAboutToChange(p, pOut);
   assert( u.ai.n==0 || (pOp->p2>0 && pOp->p2+u.ai.n<=(p->nMem-p->nCursor)+1) );
   assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+u.ai.n );
   u.ai.pArg = &aMem[pOp->p2];
   for(u.ai.i=0; u.ai.i<u.ai.n; u.ai.i++, u.ai.pArg++){
     assert( memIsValid(u.ai.pArg) );
     u.ai.apVal[u.ai.i] = u.ai.pArg;
     Deephemeralize(u.ai.pArg);
     sqlite3VdbeMemStoreType(u.ai.pArg);
     REGISTER_TRACE(pOp->p2+u.ai.i, u.ai.pArg);
   assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) );
   assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
   pArg = &aMem[pOp->p2];
   for(i=0; i<n; i++, pArg++){
     assert( memIsValid(pArg) );
     apVal[i] = pArg;
     Deephemeralize(pArg);
     REGISTER_TRACE(pOp->p2+i, pArg);
   }
   assert( pOp->p4type==P4_FUNCDEF );
   u.ai.ctx.pFunc = pOp->p4.pFunc;
   u.ai.ctx.s.flags = MEM_Null;
   u.ai.ctx.s.db = db;
   u.ai.ctx.s.xDel = 0;
   u.ai.ctx.s.zMalloc = 0;
   u.ai.ctx.iOp = pc;
   u.ai.ctx.pVdbe = p;
   ctx.pFunc = pOp->p4.pFunc;
   ctx.iOp = pc;
   ctx.pVdbe = p;
   /* The output cell may already have a buffer allocated. Move
   ** the pointer to u.ai.ctx.s so in case the user-function can use
   ** the pointer to ctx.s so in case the user-function can use
   ** the already allocated buffer instead of allocating a new one.
   */
   sqlite3VdbeMemMove(&u.ai.ctx.s, pOut);
   MemSetTypeFlag(&u.ai.ctx.s, MEM_Null);
   memcpy(&ctx.s, pOut, sizeof(Mem));
   pOut->flags = MEM_Null;
   pOut->xDel = 0;
   pOut->zMalloc = 0;
   MemSetTypeFlag(&ctx.s, MEM_Null);
   u.ai.ctx.fErrorOrAux = 0;
   if( u.ai.ctx.pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
   ctx.fErrorOrAux = 0;
   if( ctx.pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
     assert( pOp>aOp );
     assert( pOp[-1].p4type==P4_COLLSEQ );
     assert( pOp[-1].opcode==OP_CollSeq );
     u.ai.ctx.pColl = pOp[-1].p4.pColl;
     ctx.pColl = pOp[-1].p4.pColl;
   }
   db->lastRowid = lastRowid;
   (*u.ai.ctx.pFunc->xFunc)(&u.ai.ctx, u.ai.n, u.ai.apVal); /* IMP: R-24505-23230 */
   (*ctx.pFunc->xFunc)(&ctx, n, apVal); /* IMP: R-24505-23230 */
   lastRowid = db->lastRowid;
   if( db->mallocFailed ){

@@ -67607,22 +68620,23 @@ case OP_Function: {

     ** to return a value. The following call releases any resources
     ** associated with such a value.
     */
     sqlite3VdbeMemRelease(&u.ai.ctx.s);
     sqlite3VdbeMemRelease(&ctx.s);
     goto no_mem;
   }
   /* If the function returned an error, throw an exception */
   if( u.ai.ctx.fErrorOrAux ){
     if( u.ai.ctx.isError ){
       sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&u.ai.ctx.s));
       rc = u.ai.ctx.isError;
   if( ctx.fErrorOrAux ){
     if( ctx.isError ){
       sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&ctx.s));
       rc = ctx.isError;
     }
     sqlite3VdbeDeleteAuxData(p, pc, pOp->p1);
   }
   /* Copy the result of the function into register P3 */
   sqlite3VdbeChangeEncoding(&u.ai.ctx.s, encoding);
   sqlite3VdbeMemMove(pOut, &u.ai.ctx.s);
   sqlite3VdbeChangeEncoding(&ctx.s, encoding);
   assert( pOut->flags==MEM_Null );
   memcpy(pOut, &ctx.s, sizeof(Mem));
   if( sqlite3VdbeMemTooBig(pOut) ){
     goto too_big;
   }

@@ -67641,18 +68655,21 @@ case OP_Function: {

 }
 /* Opcode: BitAnd P1 P2 P3 * *
 ** Synopsis:  r[P3]=r[P1]&r[P2]
 **
 ** Take the bit-wise AND of the values in register P1 and P2 and
 ** store the result in register P3.
 ** If either input is NULL, the result is NULL.
 */
 /* Opcode: BitOr P1 P2 P3 * *
 ** Synopsis:  r[P3]=r[P1]|r[P2]
 **
 ** Take the bit-wise OR of the values in register P1 and P2 and
 ** store the result in register P3.
 ** If either input is NULL, the result is NULL.
 */
 /* Opcode: ShiftLeft P1 P2 P3 * *
 ** Synopsis:  r[P3]=r[P2]<<r[P1]
 **
 ** Shift the integer value in register P2 to the left by the
 ** number of bits specified by the integer in register P1.

@@ -67660,6 +68677,7 @@ case OP_Function: {

 ** If either input is NULL, the result is NULL.
 */
 /* Opcode: ShiftRight P1 P2 P3 * *
 ** Synopsis:  r[P3]=r[P2]>>r[P1]
 **
 ** Shift the integer value in register P2 to the right by the
 ** number of bits specified by the integer in register P1.

@@ -67670,12 +68688,10 @@ case OP_BitAnd: /* same as TK_BITAND, in1, in2, out3 */

 case OP_BitOr:                  /* same as TK_BITOR, in1, in2, out3 */
 case OP_ShiftLeft:              /* same as TK_LSHIFT, in1, in2, out3 */
 case OP_ShiftRight: {           /* same as TK_RSHIFT, in1, in2, out3 */
 #if 0  /* local variables moved into u.aj */
   i64 iA;
   u64 uA;
   i64 iB;
   u8 op;
 #endif /* local variables moved into u.aj */
   pIn1 = &aMem[pOp->p1];
   pIn2 = &aMem[pOp->p2];

@@ -67684,43 +68700,44 @@ case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */

     sqlite3VdbeMemSetNull(pOut);
     break;
   }
   u.aj.iA = sqlite3VdbeIntValue(pIn2);
   u.aj.iB = sqlite3VdbeIntValue(pIn1);
   u.aj.op = pOp->opcode;
   if( u.aj.op==OP_BitAnd ){
     u.aj.iA &= u.aj.iB;
   }else if( u.aj.op==OP_BitOr ){
     u.aj.iA |= u.aj.iB;
   }else if( u.aj.iB!=0 ){
     assert( u.aj.op==OP_ShiftRight || u.aj.op==OP_ShiftLeft );
   iA = sqlite3VdbeIntValue(pIn2);
   iB = sqlite3VdbeIntValue(pIn1);
   op = pOp->opcode;
   if( op==OP_BitAnd ){
     iA &= iB;
   }else if( op==OP_BitOr ){
     iA |= iB;
   }else if( iB!=0 ){
     assert( op==OP_ShiftRight || op==OP_ShiftLeft );
     /* If shifting by a negative amount, shift in the other direction */
     if( u.aj.iB<0 ){
     if( iB<0 ){
       assert( OP_ShiftRight==OP_ShiftLeft+1 );
       u.aj.op = 2*OP_ShiftLeft + 1 - u.aj.op;
       u.aj.iB = u.aj.iB>(-64) ? -u.aj.iB : 64;
       op = 2*OP_ShiftLeft + 1 - op;
       iB = iB>(-64) ? -iB : 64;
     }
     if( u.aj.iB>=64 ){
       u.aj.iA = (u.aj.iA>=0 || u.aj.op==OP_ShiftLeft) ? 0 : -1;
     if( iB>=64 ){
       iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1;
     }else{
       memcpy(&u.aj.uA, &u.aj.iA, sizeof(u.aj.uA));
       if( u.aj.op==OP_ShiftLeft ){
         u.aj.uA <<= u.aj.iB;
       memcpy(&uA, &iA, sizeof(uA));
       if( op==OP_ShiftLeft ){
         uA <<= iB;
       }else{
         u.aj.uA >>= u.aj.iB;
         uA >>= iB;
         /* Sign-extend on a right shift of a negative number */
         if( u.aj.iA<0 ) u.aj.uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-u.aj.iB);
         if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB);
       }
       memcpy(&u.aj.iA, &u.aj.uA, sizeof(u.aj.iA));
       memcpy(&iA, &uA, sizeof(iA));
     }
   }
   pOut->u.i = u.aj.iA;
   pOut->u.i = iA;
   MemSetTypeFlag(pOut, MEM_Int);
   break;
 }
 /* Opcode: AddImm  P1 P2 * * *
 ** Synopsis:  r[P1]=r[P1]+P2
 **
 ** Add the constant P2 to the value in register P1.
 ** The result is always an integer.

@@ -67744,17 +68761,20 @@ case OP_AddImm: { /* in1 */

 */
 case OP_MustBeInt: {            /* jump, in1 */
   pIn1 = &aMem[pOp->p1];
   applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
   if( (pIn1->flags & MEM_Int)==0 ){
     if( pOp->p2==0 ){
       rc = SQLITE_MISMATCH;
       goto abort_due_to_error;
     }else{
       pc = pOp->p2 - 1;
     applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
     VdbeBranchTaken((pIn1->flags&MEM_Int)==0, 2);
     if( (pIn1->flags & MEM_Int)==0 ){
       if( pOp->p2==0 ){
         rc = SQLITE_MISMATCH;
         goto abort_due_to_error;
       }else{
         pc = pOp->p2 - 1;
         break;
       }
     }
   }else{
     MemSetTypeFlag(pIn1, MEM_Int);
   }
   MemSetTypeFlag(pIn1, MEM_Int);
   break;
 }

@@ -67782,7 +68802,7 @@ case OP_RealAffinity: { /* in1 */

 **
 ** Force the value in register P1 to be text.
 ** If the value is numeric, convert it to a string using the
 ** equivalent of printf().  Blob values are unchanged and
 ** equivalent of sprintf().  Blob values are unchanged and
 ** are afterwards simply interpreted as text.
 **
 ** A NULL value is not changed by this routine.  It remains NULL.

@@ -67879,6 +68899,7 @@ case OP_ToReal: { /* same as TK_TO_REAL, in1 */

 #endif /* !defined(SQLITE_OMIT_CAST) && !defined(SQLITE_OMIT_FLOATING_POINT) */
 /* Opcode: Lt P1 P2 P3 P4 P5
 ** Synopsis: if r[P1]<r[P3] goto P2
 **
 ** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
 ** jump to address P2.

@@ -67913,6 +68934,7 @@ case OP_ToReal: { /* same as TK_TO_REAL, in1 */

 ** bit set.
 */
 /* Opcode: Ne P1 P2 P3 P4 P5
 ** Synopsis: if r[P1]!=r[P3] goto P2
 **
 ** This works just like the Lt opcode except that the jump is taken if
 ** the operands in registers P1 and P3 are not equal.  See the Lt opcode for

@@ -67925,6 +68947,7 @@ case OP_ToReal: { /* same as TK_TO_REAL, in1 */

 ** the SQLITE_NULLEQ flag were omitted from P5.
 */
 /* Opcode: Eq P1 P2 P3 P4 P5
 ** Synopsis: if r[P1]==r[P3] goto P2
 **
 ** This works just like the Lt opcode except that the jump is taken if
 ** the operands in registers P1 and P3 are equal.

@@ -67937,18 +68960,21 @@ case OP_ToReal: { /* same as TK_TO_REAL, in1 */

 ** the SQLITE_NULLEQ flag were omitted from P5.
 */
 /* Opcode: Le P1 P2 P3 P4 P5
 ** Synopsis: if r[P1]<=r[P3] goto P2
 **
 ** This works just like the Lt opcode except that the jump is taken if
 ** the content of register P3 is less than or equal to the content of
 ** register P1.  See the Lt opcode for additional information.
 */
 /* Opcode: Gt P1 P2 P3 P4 P5
 ** Synopsis: if r[P1]>r[P3] goto P2
 **
 ** This works just like the Lt opcode except that the jump is taken if
 ** the content of register P3 is greater than the content of
 ** register P1.  See the Lt opcode for additional information.
 */
 /* Opcode: Ge P1 P2 P3 P4 P5
 ** Synopsis: if r[P1]>=r[P3] goto P2
 **
 ** This works just like the Lt opcode except that the jump is taken if
 ** the content of register P3 is greater than or equal to the content of

@@ -67960,18 +68986,16 @@ case OP_Lt: /* same as TK_LT, jump, in1, in3 */

 case OP_Le:               /* same as TK_LE, jump, in1, in3 */
 case OP_Gt:               /* same as TK_GT, jump, in1, in3 */
 case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
 #if 0  /* local variables moved into u.ak */
   int res;            /* Result of the comparison of pIn1 against pIn3 */
   char affinity;      /* Affinity to use for comparison */
   u16 flags1;         /* Copy of initial value of pIn1->flags */
   u16 flags3;         /* Copy of initial value of pIn3->flags */
 #endif /* local variables moved into u.ak */
   pIn1 = &aMem[pOp->p1];
   pIn3 = &aMem[pOp->p3];
   u.ak.flags1 = pIn1->flags;
   u.ak.flags3 = pIn3->flags;
   if( (u.ak.flags1 | u.ak.flags3)&MEM_Null ){
   flags1 = pIn1->flags;
   flags3 = pIn3->flags;
   if( (flags1 | flags3)&MEM_Null ){
     /* One or both operands are NULL */
     if( pOp->p5 & SQLITE_NULLEQ ){
       /* If SQLITE_NULLEQ is set (which will only happen if the operator is

@@ -67979,65 +69003,71 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */

       ** or not both operands are null.
       */
       assert( pOp->opcode==OP_Eq || pOp->opcode==OP_Ne );
       assert( (u.ak.flags1 & MEM_Cleared)==0 );
       if( (u.ak.flags1&MEM_Null)!=0
        && (u.ak.flags3&MEM_Null)!=0
        && (u.ak.flags3&MEM_Cleared)==0
       assert( (flags1 & MEM_Cleared)==0 );
       assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 );
       if( (flags1&MEM_Null)!=0
        && (flags3&MEM_Null)!=0
        && (flags3&MEM_Cleared)==0
       ){
         u.ak.res = 0;  /* Results are equal */
         res = 0;  /* Results are equal */
       }else{
         u.ak.res = 1;  /* Results are not equal */
         res = 1;  /* Results are not equal */
       }
     }else{
       /* SQLITE_NULLEQ is clear and at least one operand is NULL,
       ** then the result is always NULL.
       ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
       */
       if( pOp->p5 & SQLITE_JUMPIFNULL ){
         pc = pOp->p2-1;
       }else if( pOp->p5 & SQLITE_STOREP2 ){
       if( pOp->p5 & SQLITE_STOREP2 ){
         pOut = &aMem[pOp->p2];
         MemSetTypeFlag(pOut, MEM_Null);
         REGISTER_TRACE(pOp->p2, pOut);
       }else{
         VdbeBranchTaken(2,3);
         if( pOp->p5 & SQLITE_JUMPIFNULL ){
           pc = pOp->p2-1;
         }
       }
       break;
     }
   }else{
     /* Neither operand is NULL.  Do a comparison. */
     u.ak.affinity = pOp->p5 & SQLITE_AFF_MASK;
     if( u.ak.affinity ){
       applyAffinity(pIn1, u.ak.affinity, encoding);
       applyAffinity(pIn3, u.ak.affinity, encoding);
     affinity = pOp->p5 & SQLITE_AFF_MASK;
     if( affinity ){
       applyAffinity(pIn1, affinity, encoding);
       applyAffinity(pIn3, affinity, encoding);
       if( db->mallocFailed ) goto no_mem;
     }
     assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
     ExpandBlob(pIn1);
     ExpandBlob(pIn3);
     u.ak.res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
     res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
   }
   switch( pOp->opcode ){
     case OP_Eq:    u.ak.res = u.ak.res==0;     break;
     case OP_Ne:    u.ak.res = u.ak.res!=0;     break;
     case OP_Lt:    u.ak.res = u.ak.res<0;      break;
     case OP_Le:    u.ak.res = u.ak.res<=0;     break;
     case OP_Gt:    u.ak.res = u.ak.res>0;      break;
     default:       u.ak.res = u.ak.res>=0;     break;
     case OP_Eq:    res = res==0;     break;
     case OP_Ne:    res = res!=0;     break;
     case OP_Lt:    res = res<0;      break;
     case OP_Le:    res = res<=0;     break;
     case OP_Gt:    res = res>0;      break;
     default:       res = res>=0;     break;
   }
   if( pOp->p5 & SQLITE_STOREP2 ){
     pOut = &aMem[pOp->p2];
     memAboutToChange(p, pOut);
     MemSetTypeFlag(pOut, MEM_Int);
     pOut->u.i = u.ak.res;
     pOut->u.i = res;
     REGISTER_TRACE(pOp->p2, pOut);
   }else if( u.ak.res ){
     pc = pOp->p2-1;
   }else{
     VdbeBranchTaken(res!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
     if( res ){
       pc = pOp->p2-1;
     }
   }
   /* Undo any changes made by applyAffinity() to the input registers. */
   pIn1->flags = (pIn1->flags&~MEM_TypeMask) | (u.ak.flags1&MEM_TypeMask);
   pIn3->flags = (pIn3->flags&~MEM_TypeMask) | (u.ak.flags3&MEM_TypeMask);
   pIn1->flags = (pIn1->flags&~MEM_TypeMask) | (flags1&MEM_TypeMask);
   pIn3->flags = (pIn3->flags&~MEM_TypeMask) | (flags3&MEM_TypeMask);
   break;
 }

@@ -68077,7 +69107,6 @@ case OP_Permutation: {

 ** and strings are less than blobs.
 */
 case OP_Compare: {
 #if 0  /* local variables moved into u.al */
   int n;
   int i;
   int p1;

@@ -68086,38 +69115,37 @@ case OP_Compare: {

   int idx;
   CollSeq *pColl;    /* Collating sequence to use on this term */
   int bRev;          /* True for DESCENDING sort order */
 #endif /* local variables moved into u.al */
   if( (pOp->p5 & OPFLAG_PERMUTE)==0 ) aPermute = 0;
   u.al.n = pOp->p3;
   u.al.pKeyInfo = pOp->p4.pKeyInfo;
   assert( u.al.n>0 );
   assert( u.al.pKeyInfo!=0 );
   u.al.p1 = pOp->p1;
   u.al.p2 = pOp->p2;
   n = pOp->p3;
   pKeyInfo = pOp->p4.pKeyInfo;
   assert( n>0 );
   assert( pKeyInfo!=0 );
   p1 = pOp->p1;
   p2 = pOp->p2;
 #if SQLITE_DEBUG
   if( aPermute ){
     int k, mx = 0;
     for(k=0; k<u.al.n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
     assert( u.al.p1>0 && u.al.p1+mx<=(p->nMem-p->nCursor)+1 );
     assert( u.al.p2>0 && u.al.p2+mx<=(p->nMem-p->nCursor)+1 );
     for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
     assert( p1>0 && p1+mx<=(p->nMem-p->nCursor)+1 );
     assert( p2>0 && p2+mx<=(p->nMem-p->nCursor)+1 );
   }else{
     assert( u.al.p1>0 && u.al.p1+u.al.n<=(p->nMem-p->nCursor)+1 );
     assert( u.al.p2>0 && u.al.p2+u.al.n<=(p->nMem-p->nCursor)+1 );
     assert( p1>0 && p1+n<=(p->nMem-p->nCursor)+1 );
     assert( p2>0 && p2+n<=(p->nMem-p->nCursor)+1 );
   }
 #endif /* SQLITE_DEBUG */
   for(u.al.i=0; u.al.i<u.al.n; u.al.i++){
     u.al.idx = aPermute ? aPermute[u.al.i] : u.al.i;
     assert( memIsValid(&aMem[u.al.p1+u.al.idx]) );
     assert( memIsValid(&aMem[u.al.p2+u.al.idx]) );
     REGISTER_TRACE(u.al.p1+u.al.idx, &aMem[u.al.p1+u.al.idx]);
     REGISTER_TRACE(u.al.p2+u.al.idx, &aMem[u.al.p2+u.al.idx]);
     assert( u.al.i<u.al.pKeyInfo->nField );
     u.al.pColl = u.al.pKeyInfo->aColl[u.al.i];
     u.al.bRev = u.al.pKeyInfo->aSortOrder[u.al.i];
     iCompare = sqlite3MemCompare(&aMem[u.al.p1+u.al.idx], &aMem[u.al.p2+u.al.idx], u.al.pColl);
   for(i=0; i<n; i++){
     idx = aPermute ? aPermute[i] : i;
     assert( memIsValid(&aMem[p1+idx]) );
     assert( memIsValid(&aMem[p2+idx]) );
     REGISTER_TRACE(p1+idx, &aMem[p1+idx]);
     REGISTER_TRACE(p2+idx, &aMem[p2+idx]);
     assert( i<pKeyInfo->nField );
     pColl = pKeyInfo->aColl[i];
     bRev = pKeyInfo->aSortOrder[i];
     iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl);
     if( iCompare ){
       if( u.al.bRev ) iCompare = -iCompare;
       if( bRev ) iCompare = -iCompare;
       break;
     }
   }

@@ -68133,16 +69161,17 @@ case OP_Compare: {

 */
 case OP_Jump: {             /* jump */
   if( iCompare<0 ){
     pc = pOp->p1 - 1;
     pc = pOp->p1 - 1;  VdbeBranchTaken(0,3);
   }else if( iCompare==0 ){
     pc = pOp->p2 - 1;
     pc = pOp->p2 - 1;  VdbeBranchTaken(1,3);
   }else{
     pc = pOp->p3 - 1;
     pc = pOp->p3 - 1;  VdbeBranchTaken(2,3);
   }
   break;
 }
 /* Opcode: And P1 P2 P3 * *
 ** Synopsis: r[P3]=(r[P1] && r[P2])
 **
 ** Take the logical AND of the values in registers P1 and P2 and
 ** write the result into register P3.

@@ -68152,6 +69181,7 @@ case OP_Jump: { /* jump */

 ** a NULL output.
 */
 /* Opcode: Or P1 P2 P3 * *
 ** Synopsis: r[P3]=(r[P1] || r[P2])
 **
 ** Take the logical OR of the values in register P1 and P2 and
 ** store the answer in register P3.

@@ -68162,41 +69192,40 @@ case OP_Jump: { /* jump */

 */
 case OP_And:              /* same as TK_AND, in1, in2, out3 */
 case OP_Or: {             /* same as TK_OR, in1, in2, out3 */
 #if 0  /* local variables moved into u.am */
   int v1;    /* Left operand:  0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
   int v2;    /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
 #endif /* local variables moved into u.am */
   pIn1 = &aMem[pOp->p1];
   if( pIn1->flags & MEM_Null ){
     u.am.v1 = 2;
     v1 = 2;
   }else{
     u.am.v1 = sqlite3VdbeIntValue(pIn1)!=0;
     v1 = sqlite3VdbeIntValue(pIn1)!=0;
   }
   pIn2 = &aMem[pOp->p2];
   if( pIn2->flags & MEM_Null ){
     u.am.v2 = 2;
     v2 = 2;
   }else{
     u.am.v2 = sqlite3VdbeIntValue(pIn2)!=0;
     v2 = sqlite3VdbeIntValue(pIn2)!=0;
   }
   if( pOp->opcode==OP_And ){
     static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
     u.am.v1 = and_logic[u.am.v1*3+u.am.v2];
     v1 = and_logic[v1*3+v2];
   }else{
     static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
     u.am.v1 = or_logic[u.am.v1*3+u.am.v2];
     v1 = or_logic[v1*3+v2];
   }
   pOut = &aMem[pOp->p3];
   if( u.am.v1==2 ){
   if( v1==2 ){
     MemSetTypeFlag(pOut, MEM_Null);
   }else{
     pOut->u.i = u.am.v1;
     pOut->u.i = v1;
     MemSetTypeFlag(pOut, MEM_Int);
   }
   break;
 }
 /* Opcode: Not P1 P2 * * *
 ** Synopsis: r[P2]= !r[P1]
 **
 ** Interpret the value in register P1 as a boolean value.  Store the
 ** boolean complement in register P2.  If the value in register P1 is

@@ -68214,6 +69243,7 @@ case OP_Not: { /* same as TK_NOT, in1, out2 */

 }
 /* Opcode: BitNot P1 P2 * * *
 ** Synopsis: r[P1]= ~r[P1]
 **
 ** Interpret the content of register P1 as an integer.  Store the
 ** ones-complement of the P1 value into register P2.  If P1 holds

@@ -68233,10 +69263,13 @@ case OP_BitNot: { /* same as TK_BITNOT, in1, out2 */

 /* Opcode: Once P1 P2 * * *
 **
 ** Check if OP_Once flag P1 is set. If so, jump to instruction P2. Otherwise,
 ** set the flag and fall through to the next instruction.
 ** set the flag and fall through to the next instruction.  In other words,
 ** this opcode causes all following opcodes up through P2 (but not including
 ** P2) to run just once and to be skipped on subsequent times through the loop.
 */
 case OP_Once: {             /* jump */
   assert( pOp->p1<p->nOnceFlag );
   VdbeBranchTaken(p->aOnceFlag[pOp->p1]!=0, 2);
   if( p->aOnceFlag[pOp->p1] ){
     pc = pOp->p2-1;
   }else{

@@ -68259,32 +69292,33 @@ case OP_Once: { /* jump */

 */
 case OP_If:                 /* jump, in1 */
 case OP_IfNot: {            /* jump, in1 */
 #if 0  /* local variables moved into u.an */
   int c;
 #endif /* local variables moved into u.an */
   pIn1 = &aMem[pOp->p1];
   if( pIn1->flags & MEM_Null ){
     u.an.c = pOp->p3;
     c = pOp->p3;
   }else{
 #ifdef SQLITE_OMIT_FLOATING_POINT
     u.an.c = sqlite3VdbeIntValue(pIn1)!=0;
     c = sqlite3VdbeIntValue(pIn1)!=0;
 #else
     u.an.c = sqlite3VdbeRealValue(pIn1)!=0.0;
     c = sqlite3VdbeRealValue(pIn1)!=0.0;
 #endif
     if( pOp->opcode==OP_IfNot ) u.an.c = !u.an.c;
     if( pOp->opcode==OP_IfNot ) c = !c;
   }
   if( u.an.c ){
   VdbeBranchTaken(c!=0, 2);
   if( c ){
     pc = pOp->p2-1;
   }
   break;
 }
 /* Opcode: IsNull P1 P2 * * *
 ** Synopsis:  if r[P1]==NULL goto P2
 **
 ** Jump to P2 if the value in register P1 is NULL.
 */
 case OP_IsNull: {            /* same as TK_ISNULL, jump, in1 */
   pIn1 = &aMem[pOp->p1];
   VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2);
   if( (pIn1->flags & MEM_Null)!=0 ){
     pc = pOp->p2 - 1;
   }

@@ -68292,11 +69326,13 @@ case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */

 }
 /* Opcode: NotNull P1 P2 * * *
 ** Synopsis: if r[P1]!=NULL goto P2
 **
 ** Jump to P2 if the value in register P1 is not NULL.
 */
 case OP_NotNull: {            /* same as TK_NOTNULL, jump, in1 */
   pIn1 = &aMem[pOp->p1];
   VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2);
   if( (pIn1->flags & MEM_Null)==0 ){
     pc = pOp->p2 - 1;
   }

@@ -68304,6 +69340,7 @@ case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */

 }
 /* Opcode: Column P1 P2 P3 P4 P5
 ** Synopsis:  r[P3]=PX
 **
 ** Interpret the data that cursor P1 points to as a structure built using
 ** the MakeRecord instruction.  (See the MakeRecord opcode for additional

@@ -68328,155 +69365,98 @@ case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */

 ** skipped for length() and all content loading can be skipped for typeof().
 */
 case OP_Column: {
 #if 0  /* local variables moved into u.ao */
   u32 payloadSize;   /* Number of bytes in the record */
   i64 payloadSize64; /* Number of bytes in the record */
   int p1;            /* P1 value of the opcode */
   int p2;            /* column number to retrieve */
   VdbeCursor *pC;    /* The VDBE cursor */
   char *zRec;        /* Pointer to complete record-data */
   BtCursor *pCrsr;   /* The BTree cursor */
   u32 *aType;        /* aType[i] holds the numeric type of the i-th column */
   u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
   int nField;        /* number of fields in the record */
   int len;           /* The length of the serialized data for the column */
   int i;             /* Loop counter */
   char *zData;       /* Part of the record being decoded */
   Mem *pDest;        /* Where to write the extracted value */
   Mem sMem;          /* For storing the record being decoded */
   u8 *zIdx;          /* Index into header */
   u8 *zEndHdr;       /* Pointer to first byte after the header */
   const u8 *zData;   /* Part of the record being decoded */
   const u8 *zHdr;    /* Next unparsed byte of the header */
   const u8 *zEndHdr; /* Pointer to first byte after the header */
   u32 offset;        /* Offset into the data */
   u32 szField;       /* Number of bytes in the content of a field */
   int szHdr;         /* Size of the header size field at start of record */
   int avail;         /* Number of bytes of available data */
   u32 avail;         /* Number of bytes of available data */
   u32 t;             /* A type code from the record header */
   Mem *pReg;         /* PseudoTable input register */
 #endif /* local variables moved into u.ao */
   u.ao.p1 = pOp->p1;
   u.ao.p2 = pOp->p2;
   u.ao.pC = 0;
   memset(&u.ao.sMem, 0, sizeof(u.ao.sMem));
   assert( u.ao.p1<p->nCursor );
   p2 = pOp->p2;
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   u.ao.pDest = &aMem[pOp->p3];
   memAboutToChange(p, u.ao.pDest);
   u.ao.zRec = 0;
   /* This block sets the variable u.ao.payloadSize to be the total number of
   ** bytes in the record.
   **
   ** u.ao.zRec is set to be the complete text of the record if it is available.
   ** The complete record text is always available for pseudo-tables
   ** If the record is stored in a cursor, the complete record text
   ** might be available in the  u.ao.pC->aRow cache.  Or it might not be.
   ** If the data is unavailable,  u.ao.zRec is set to NULL.
   **
   ** We also compute the number of columns in the record.  For cursors,
   ** the number of columns is stored in the VdbeCursor.nField element.
   */
   u.ao.pC = p->apCsr[u.ao.p1];
   assert( u.ao.pC!=0 );
   pDest = &aMem[pOp->p3];
   memAboutToChange(p, pDest);
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( p2<pC->nField );
   aType = pC->aType;
   aOffset = aType + pC->nField;
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   assert( u.ao.pC->pVtabCursor==0 );
 #endif
   u.ao.pCrsr = u.ao.pC->pCursor;
   if( u.ao.pCrsr!=0 ){
     /* The record is stored in a B-Tree */
     rc = sqlite3VdbeCursorMoveto(u.ao.pC);
     if( rc ) goto abort_due_to_error;
     if( u.ao.pC->nullRow ){
       u.ao.payloadSize = 0;
     }else if( u.ao.pC->cacheStatus==p->cacheCtr ){
       u.ao.payloadSize = u.ao.pC->payloadSize;
       u.ao.zRec = (char*)u.ao.pC->aRow;
     }else if( u.ao.pC->isIndex ){
       assert( sqlite3BtreeCursorIsValid(u.ao.pCrsr) );
       VVA_ONLY(rc =) sqlite3BtreeKeySize(u.ao.pCrsr, &u.ao.payloadSize64);
       assert( rc==SQLITE_OK );   /* True because of CursorMoveto() call above */
       /* sqlite3BtreeParseCellPtr() uses getVarint32() to extract the
       ** payload size, so it is impossible for u.ao.payloadSize64 to be
       ** larger than 32 bits. */
       assert( (u.ao.payloadSize64 & SQLITE_MAX_U32)==(u64)u.ao.payloadSize64 );
       u.ao.payloadSize = (u32)u.ao.payloadSize64;
     }else{
       assert( sqlite3BtreeCursorIsValid(u.ao.pCrsr) );
       VVA_ONLY(rc =) sqlite3BtreeDataSize(u.ao.pCrsr, &u.ao.payloadSize);
       assert( rc==SQLITE_OK );   /* DataSize() cannot fail */
     }
   }else if( ALWAYS(u.ao.pC->pseudoTableReg>0) ){
     u.ao.pReg = &aMem[u.ao.pC->pseudoTableReg];
     if( u.ao.pC->multiPseudo ){
       sqlite3VdbeMemShallowCopy(u.ao.pDest, u.ao.pReg+u.ao.p2, MEM_Ephem);
       Deephemeralize(u.ao.pDest);
       goto op_column_out;
     }
     assert( u.ao.pReg->flags & MEM_Blob );
     assert( memIsValid(u.ao.pReg) );
     u.ao.payloadSize = u.ao.pReg->n;
     u.ao.zRec = u.ao.pReg->z;
     u.ao.pC->cacheStatus = (pOp->p5&OPFLAG_CLEARCACHE) ? CACHE_STALE : p->cacheCtr;
     assert( u.ao.payloadSize==0 || u.ao.zRec!=0 );
   }else{
     /* Consider the row to be NULL */
     u.ao.payloadSize = 0;
   }
   /* If u.ao.payloadSize is 0, then just store a NULL.  This can happen because of
   ** nullRow or because of a corrupt database. */
   if( u.ao.payloadSize==0 ){
     MemSetTypeFlag(u.ao.pDest, MEM_Null);
     goto op_column_out;
   }
   assert( db->aLimit[SQLITE_LIMIT_LENGTH]>=0 );
   if( u.ao.payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
     goto too_big;
   }
   u.ao.nField = u.ao.pC->nField;
   assert( u.ao.p2<u.ao.nField );
   /* Read and parse the table header.  Store the results of the parse
   ** into the record header cache fields of the cursor.
   */
   u.ao.aType = u.ao.pC->aType;
   if( u.ao.pC->cacheStatus==p->cacheCtr ){
     u.ao.aOffset = u.ao.pC->aOffset;
   }else{
     assert(u.ao.aType);
     u.ao.avail = 0;
     u.ao.pC->aOffset = u.ao.aOffset = &u.ao.aType[u.ao.nField];
     u.ao.pC->payloadSize = u.ao.payloadSize;
     u.ao.pC->cacheStatus = p->cacheCtr;
     /* Figure out how many bytes are in the header */
     if( u.ao.zRec ){
       u.ao.zData = u.ao.zRec;
     }else{
       if( u.ao.pC->isIndex ){
         u.ao.zData = (char*)sqlite3BtreeKeyFetch(u.ao.pCrsr, &u.ao.avail);
   assert( pC->pVtabCursor==0 ); /* OP_Column never called on virtual table */
 #endif
   pCrsr = pC->pCursor;
   assert( pCrsr!=0 || pC->pseudoTableReg>0 ); /* pCrsr NULL on PseudoTables */
   assert( pCrsr!=0 || pC->nullRow );          /* pC->nullRow on PseudoTables */
   /* If the cursor cache is stale, bring it up-to-date */
   rc = sqlite3VdbeCursorMoveto(pC);
   if( rc ) goto abort_due_to_error;
   if( pC->cacheStatus!=p->cacheCtr || (pOp->p5&OPFLAG_CLEARCACHE)!=0 ){
     if( pC->nullRow ){
       if( pCrsr==0 ){
         assert( pC->pseudoTableReg>0 );
         pReg = &aMem[pC->pseudoTableReg];
         assert( pReg->flags & MEM_Blob );
         assert( memIsValid(pReg) );
         pC->payloadSize = pC->szRow = avail = pReg->n;
         pC->aRow = (u8*)pReg->z;
       }else{
         u.ao.zData = (char*)sqlite3BtreeDataFetch(u.ao.pCrsr, &u.ao.avail);
         MemSetTypeFlag(pDest, MEM_Null);
         goto op_column_out;
       }
       /* If KeyFetch()/DataFetch() managed to get the entire payload,
       ** save the payload in the u.ao.pC->aRow cache.  That will save us from
       ** having to make additional calls to fetch the content portion of
       ** the record.
       */
       assert( u.ao.avail>=0 );
       if( u.ao.payloadSize <= (u32)u.ao.avail ){
         u.ao.zRec = u.ao.zData;
         u.ao.pC->aRow = (u8*)u.ao.zData;
     }else{
       assert( pCrsr );
       if( pC->isTable==0 ){
         assert( sqlite3BtreeCursorIsValid(pCrsr) );
         VVA_ONLY(rc =) sqlite3BtreeKeySize(pCrsr, &payloadSize64);
         assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
         /* sqlite3BtreeParseCellPtr() uses getVarint32() to extract the
         ** payload size, so it is impossible for payloadSize64 to be
         ** larger than 32 bits. */
         assert( (payloadSize64 & SQLITE_MAX_U32)==(u64)payloadSize64 );
         pC->aRow = sqlite3BtreeKeyFetch(pCrsr, &avail);
         pC->payloadSize = (u32)payloadSize64;
       }else{
         u.ao.pC->aRow = 0;
         assert( sqlite3BtreeCursorIsValid(pCrsr) );
         VVA_ONLY(rc =) sqlite3BtreeDataSize(pCrsr, &pC->payloadSize);
         assert( rc==SQLITE_OK );   /* DataSize() cannot fail */
         pC->aRow = sqlite3BtreeDataFetch(pCrsr, &avail);
       }
       assert( avail<=65536 );  /* Maximum page size is 64KiB */
       if( pC->payloadSize <= (u32)avail ){
         pC->szRow = pC->payloadSize;
       }else{
         pC->szRow = avail;
       }
       if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
         goto too_big;
       }
     }
     /* The following assert is true in all cases except when
     ** the database file has been corrupted externally.
     **    assert( u.ao.zRec!=0 || u.ao.avail>=u.ao.payloadSize || u.ao.avail>=9 ); */
     u.ao.szHdr = getVarint32((u8*)u.ao.zData, u.ao.offset);
     pC->cacheStatus = p->cacheCtr;
     pC->iHdrOffset = getVarint32(pC->aRow, offset);
     pC->nHdrParsed = 0;
     aOffset[0] = offset;
     if( avail<offset ){
       /* pC->aRow does not have to hold the entire row, but it does at least
       ** need to cover the header of the record.  If pC->aRow does not contain
       ** the complete header, then set it to zero, forcing the header to be
       ** dynamically allocated. */
       pC->aRow = 0;
       pC->szRow = 0;
     }
     /* Make sure a corrupt database has not given us an oversize header.
     ** Do this now to avoid an oversize memory allocation.

@@ -68487,161 +69467,156 @@ case OP_Column: {

     ** 3-byte type for each of the maximum of 32768 columns plus three
     ** extra bytes for the header length itself.  32768*3 + 3 = 98307.
     */
     if( u.ao.offset > 98307 ){
     if( offset > 98307 || offset > pC->payloadSize ){
       rc = SQLITE_CORRUPT_BKPT;
       goto op_column_out;
       goto op_column_error;
     }
   }
     /* Compute in u.ao.len the number of bytes of data we need to read in order
     ** to get u.ao.nField type values.  u.ao.offset is an upper bound on this.  But
     ** u.ao.nField might be significantly less than the true number of columns
     ** in the table, and in that case, 5*u.ao.nField+3 might be smaller than u.ao.offset.
     ** We want to minimize u.ao.len in order to limit the size of the memory
     ** allocation, especially if a corrupt database file has caused u.ao.offset
     ** to be oversized. Offset is limited to 98307 above.  But 98307 might
     ** still exceed Robson memory allocation limits on some configurations.
     ** On systems that cannot tolerate large memory allocations, u.ao.nField*5+3
     ** will likely be much smaller since u.ao.nField will likely be less than
     ** 20 or so.  This insures that Robson memory allocation limits are
     ** not exceeded even for corrupt database files.
     */
     u.ao.len = u.ao.nField*5 + 3;
     if( u.ao.len > (int)u.ao.offset ) u.ao.len = (int)u.ao.offset;
     /* The KeyFetch() or DataFetch() above are fast and will get the entire
     ** record header in most cases.  But they will fail to get the complete
     ** record header if the record header does not fit on a single page
     ** in the B-Tree.  When that happens, use sqlite3VdbeMemFromBtree() to
     ** acquire the complete header text.
   /* Make sure at least the first p2+1 entries of the header have been
   ** parsed and valid information is in aOffset[] and aType[].
   */
   if( pC->nHdrParsed<=p2 ){
     /* If there is more header available for parsing in the record, try
     ** to extract additional fields up through the p2+1-th field
     */
     if( !u.ao.zRec && u.ao.avail<u.ao.len ){
       u.ao.sMem.flags = 0;
       u.ao.sMem.db = 0;
       rc = sqlite3VdbeMemFromBtree(u.ao.pCrsr, 0, u.ao.len, u.ao.pC->isIndex, &u.ao.sMem);
       if( rc!=SQLITE_OK ){
         goto op_column_out;
     if( pC->iHdrOffset<aOffset[0] ){
       /* Make sure zData points to enough of the record to cover the header. */
       if( pC->aRow==0 ){
         memset(&sMem, 0, sizeof(sMem));
         rc = sqlite3VdbeMemFromBtree(pCrsr, 0, aOffset[0],
                                      !pC->isTable, &sMem);
         if( rc!=SQLITE_OK ){
           goto op_column_error;
         }
         zData = (u8*)sMem.z;
       }else{
         zData = pC->aRow;
       }
       u.ao.zData = u.ao.sMem.z;
     }
     u.ao.zEndHdr = (u8 *)&u.ao.zData[u.ao.len];
     u.ao.zIdx = (u8 *)&u.ao.zData[u.ao.szHdr];
     /* Scan the header and use it to fill in the u.ao.aType[] and u.ao.aOffset[]
     ** arrays.  u.ao.aType[u.ao.i] will contain the type integer for the u.ao.i-th
     ** column and u.ao.aOffset[u.ao.i] will contain the u.ao.offset from the beginning
     ** of the record to the start of the data for the u.ao.i-th column
     */
     for(u.ao.i=0; u.ao.i<u.ao.nField; u.ao.i++){
       if( u.ao.zIdx<u.ao.zEndHdr ){
         u.ao.aOffset[u.ao.i] = u.ao.offset;
         if( u.ao.zIdx[0]<0x80 ){
           u.ao.t = u.ao.zIdx[0];
           u.ao.zIdx++;
       /* Fill in aType[i] and aOffset[i] values through the p2-th field. */
       i = pC->nHdrParsed;
       offset = aOffset[i];
       zHdr = zData + pC->iHdrOffset;
       zEndHdr = zData + aOffset[0];
       assert( i<=p2 && zHdr<zEndHdr );
       do{
         if( zHdr[0]<0x80 ){
           t = zHdr[0];
           zHdr++;
         }else{
           u.ao.zIdx += sqlite3GetVarint32(u.ao.zIdx, &u.ao.t);
           zHdr += sqlite3GetVarint32(zHdr, &t);
         }
         u.ao.aType[u.ao.i] = u.ao.t;
         u.ao.szField = sqlite3VdbeSerialTypeLen(u.ao.t);
         u.ao.offset += u.ao.szField;
         if( u.ao.offset<u.ao.szField ){  /* True if u.ao.offset overflows */
           u.ao.zIdx = &u.ao.zEndHdr[1];  /* Forces SQLITE_CORRUPT return below */
         aType[i] = t;
         szField = sqlite3VdbeSerialTypeLen(t);
         offset += szField;
         if( offset<szField ){  /* True if offset overflows */
           zHdr = &zEndHdr[1];  /* Forces SQLITE_CORRUPT return below */
           break;
         }
       }else{
         /* If u.ao.i is less that u.ao.nField, then there are fewer fields in this
         ** record than SetNumColumns indicated there are columns in the
         ** table. Set the u.ao.offset for any extra columns not present in
         ** the record to 0. This tells code below to store the default value
         ** for the column instead of deserializing a value from the record.
         */
         u.ao.aOffset[u.ao.i] = 0;
         i++;
         aOffset[i] = offset;
       }while( i<=p2 && zHdr<zEndHdr );
       pC->nHdrParsed = i;
       pC->iHdrOffset = (u32)(zHdr - zData);
       if( pC->aRow==0 ){
         sqlite3VdbeMemRelease(&sMem);
         sMem.flags = MEM_Null;
       }
       /* If we have read more header data than was contained in the header,
       ** or if the end of the last field appears to be past the end of the
       ** record, or if the end of the last field appears to be before the end
       ** of the record (when all fields present), then we must be dealing
       ** with a corrupt database.
       */
       if( (zHdr > zEndHdr)
        || (offset > pC->payloadSize)
        || (zHdr==zEndHdr && offset!=pC->payloadSize)
       ){
         rc = SQLITE_CORRUPT_BKPT;
         goto op_column_error;
       }
     }
     sqlite3VdbeMemRelease(&u.ao.sMem);
     u.ao.sMem.flags = MEM_Null;
     /* If we have read more header data than was contained in the header,
     ** or if the end of the last field appears to be past the end of the
     ** record, or if the end of the last field appears to be before the end
     ** of the record (when all fields present), then we must be dealing
     ** with a corrupt database.
     /* If after trying to extra new entries from the header, nHdrParsed is
     ** still not up to p2, that means that the record has fewer than p2
     ** columns.  So the result will be either the default value or a NULL.
     */
     if( (u.ao.zIdx > u.ao.zEndHdr) || (u.ao.offset > u.ao.payloadSize)
          || (u.ao.zIdx==u.ao.zEndHdr && u.ao.offset!=u.ao.payloadSize) ){
       rc = SQLITE_CORRUPT_BKPT;
     if( pC->nHdrParsed<=p2 ){
       if( pOp->p4type==P4_MEM ){
         sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
       }else{
         MemSetTypeFlag(pDest, MEM_Null);
       }
       goto op_column_out;
     }
   }
   /* Get the column information. If u.ao.aOffset[u.ao.p2] is non-zero, then
   ** deserialize the value from the record. If u.ao.aOffset[u.ao.p2] is zero,
   ** then there are not enough fields in the record to satisfy the
   ** request.  In this case, set the value NULL or to P4 if P4 is
   ** a pointer to a Mem object.
   /* Extract the content for the p2+1-th column.  Control can only
   ** reach this point if aOffset[p2], aOffset[p2+1], and aType[p2] are
   ** all valid.
   */
   if( u.ao.aOffset[u.ao.p2] ){
     assert( rc==SQLITE_OK );
     if( u.ao.zRec ){
       /* This is the common case where the whole row fits on a single page */
       VdbeMemRelease(u.ao.pDest);
       sqlite3VdbeSerialGet((u8 *)&u.ao.zRec[u.ao.aOffset[u.ao.p2]], u.ao.aType[u.ao.p2], u.ao.pDest);
   assert( p2<pC->nHdrParsed );
   assert( rc==SQLITE_OK );
   assert( sqlite3VdbeCheckMemInvariants(pDest) );
   if( pC->szRow>=aOffset[p2+1] ){
     /* This is the common case where the desired content fits on the original
     ** page - where the content is not on an overflow page */
     VdbeMemRelease(pDest);
     sqlite3VdbeSerialGet(pC->aRow+aOffset[p2], aType[p2], pDest);
   }else{
     /* This branch happens only when content is on overflow pages */
     t = aType[p2];
     if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0
           && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0))
      || (len = sqlite3VdbeSerialTypeLen(t))==0
     ){
       /* Content is irrelevant for the typeof() function and for
       ** the length(X) function if X is a blob.  So we might as well use
       ** bogus content rather than reading content from disk.  NULL works
       ** for text and blob and whatever is in the payloadSize64 variable
       ** will work for everything else.  Content is also irrelevant if
       ** the content length is 0. */
       zData = t<=13 ? (u8*)&payloadSize64 : 0;
       sMem.zMalloc = 0;
     }else{
       /* This branch happens only when the row overflows onto multiple pages */
       u.ao.t = u.ao.aType[u.ao.p2];
       if( (pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0
        && ((u.ao.t>=12 && (u.ao.t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0)
       ){
         /* Content is irrelevant for the typeof() function and for
         ** the length(X) function if X is a blob.  So we might as well use
         ** bogus content rather than reading content from disk.  NULL works
         ** for text and blob and whatever is in the u.ao.payloadSize64 variable
         ** will work for everything else. */
         u.ao.zData = u.ao.t<12 ? (char*)&u.ao.payloadSize64 : 0;
       }else{
         u.ao.len = sqlite3VdbeSerialTypeLen(u.ao.t);
         sqlite3VdbeMemMove(&u.ao.sMem, u.ao.pDest);
         rc = sqlite3VdbeMemFromBtree(u.ao.pCrsr, u.ao.aOffset[u.ao.p2], u.ao.len,  u.ao.pC->isIndex,
                                      &u.ao.sMem);
         if( rc!=SQLITE_OK ){
           goto op_column_out;
         }
         u.ao.zData = u.ao.sMem.z;
       memset(&sMem, 0, sizeof(sMem));
       sqlite3VdbeMemMove(&sMem, pDest);
       rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, !pC->isTable,
                                    &sMem);
       if( rc!=SQLITE_OK ){
         goto op_column_error;
       }
       sqlite3VdbeSerialGet((u8*)u.ao.zData, u.ao.t, u.ao.pDest);
       zData = (u8*)sMem.z;
     }
     u.ao.pDest->enc = encoding;
   }else{
     if( pOp->p4type==P4_MEM ){
       sqlite3VdbeMemShallowCopy(u.ao.pDest, pOp->p4.pMem, MEM_Static);
     }else{
       MemSetTypeFlag(u.ao.pDest, MEM_Null);
     sqlite3VdbeSerialGet(zData, t, pDest);
     /* If we dynamically allocated space to hold the data (in the
     ** sqlite3VdbeMemFromBtree() call above) then transfer control of that
     ** dynamically allocated space over to the pDest structure.
     ** This prevents a memory copy. */
     if( sMem.zMalloc ){
       assert( sMem.z==sMem.zMalloc );
       assert( VdbeMemDynamic(pDest)==0 );
       assert( (pDest->flags & (MEM_Blob|MEM_Str))==0 || pDest->z==sMem.z );
       pDest->flags &= ~(MEM_Ephem|MEM_Static);
       pDest->flags |= MEM_Term;
       pDest->z = sMem.z;
       pDest->zMalloc = sMem.zMalloc;
     }
   }
   /* If we dynamically allocated space to hold the data (in the
   ** sqlite3VdbeMemFromBtree() call above) then transfer control of that
   ** dynamically allocated space over to the u.ao.pDest structure.
   ** This prevents a memory copy.
   */
   if( u.ao.sMem.zMalloc ){
     assert( u.ao.sMem.z==u.ao.sMem.zMalloc );
     assert( !(u.ao.pDest->flags & MEM_Dyn) );
     assert( !(u.ao.pDest->flags & (MEM_Blob|MEM_Str)) || u.ao.pDest->z==u.ao.sMem.z );
     u.ao.pDest->flags &= ~(MEM_Ephem|MEM_Static);
     u.ao.pDest->flags |= MEM_Term;
     u.ao.pDest->z = u.ao.sMem.z;
     u.ao.pDest->zMalloc = u.ao.sMem.zMalloc;
   }
   rc = sqlite3VdbeMemMakeWriteable(u.ao.pDest);
   pDest->enc = encoding;
 op_column_out:
   UPDATE_MAX_BLOBSIZE(u.ao.pDest);
   REGISTER_TRACE(pOp->p3, u.ao.pDest);
   Deephemeralize(pDest);
 op_column_error:
   UPDATE_MAX_BLOBSIZE(pDest);
   REGISTER_TRACE(pOp->p3, pDest);
   break;
 }
 /* Opcode: Affinity P1 P2 * P4 *
 ** Synopsis: affinity(r[P1@P2])
 **
 ** Apply affinities to a range of P2 registers starting with P1.
 **

@@ -68650,26 +69625,24 @@ op_column_out:

 ** memory cell in the range.
 */
 case OP_Affinity: {
 #if 0  /* local variables moved into u.ap */
   const char *zAffinity;   /* The affinity to be applied */
   char cAff;               /* A single character of affinity */
 #endif /* local variables moved into u.ap */
   u.ap.zAffinity = pOp->p4.z;
   assert( u.ap.zAffinity!=0 );
   assert( u.ap.zAffinity[pOp->p2]==0 );
   zAffinity = pOp->p4.z;
   assert( zAffinity!=0 );
   assert( zAffinity[pOp->p2]==0 );
   pIn1 = &aMem[pOp->p1];
   while( (u.ap.cAff = *(u.ap.zAffinity++))!=0 ){
   while( (cAff = *(zAffinity++))!=0 ){
     assert( pIn1 <= &p->aMem[(p->nMem-p->nCursor)] );
     assert( memIsValid(pIn1) );
     ExpandBlob(pIn1);
     applyAffinity(pIn1, u.ap.cAff, encoding);
     applyAffinity(pIn1, cAff, encoding);
     pIn1++;
   }
   break;
 }
 /* Opcode: MakeRecord P1 P2 P3 P4 *
 ** Synopsis: r[P3]=mkrec(r[P1@P2])
 **
 ** Convert P2 registers beginning with P1 into the [record format]
 ** use as a data record in a database table or as a key

@@ -68685,7 +69658,6 @@ case OP_Affinity: {

 ** If P4 is NULL then all index fields have the affinity NONE.
 */
 case OP_MakeRecord: {
 #if 0  /* local variables moved into u.aq */
   u8 *zNewRecord;        /* A buffer to hold the data for the new record */
   Mem *pRec;             /* The new record */
   u64 nData;             /* Number of bytes of data space */

@@ -68699,102 +69671,120 @@ case OP_MakeRecord: {

   int nField;            /* Number of fields in the record */
   char *zAffinity;       /* The affinity string for the record */
   int file_format;       /* File format to use for encoding */
   int i;                 /* Space used in zNewRecord[] */
   int i;                 /* Space used in zNewRecord[] header */
   int j;                 /* Space used in zNewRecord[] content */
   int len;               /* Length of a field */
 #endif /* local variables moved into u.aq */
   /* Assuming the record contains N fields, the record format looks
   ** like this:
   **
   ** ------------------------------------------------------------------------
   ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
   ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
   ** ------------------------------------------------------------------------
   **
   ** Data(0) is taken from register P1.  Data(1) comes from register P1+1
   ** and so froth.
   **
   ** Each type field is a varint representing the serial type of the
   ** Each type field is a varint representing the serial type of the
   ** corresponding data element (see sqlite3VdbeSerialType()). The
   ** hdr-size field is also a varint which is the offset from the beginning
   ** of the record to data0.
   */
   u.aq.nData = 0;         /* Number of bytes of data space */
   u.aq.nHdr = 0;          /* Number of bytes of header space */
   u.aq.nZero = 0;         /* Number of zero bytes at the end of the record */
   u.aq.nField = pOp->p1;
   u.aq.zAffinity = pOp->p4.z;
   assert( u.aq.nField>0 && pOp->p2>0 && pOp->p2+u.aq.nField<=(p->nMem-p->nCursor)+1 );
   u.aq.pData0 = &aMem[u.aq.nField];
   u.aq.nField = pOp->p2;
   u.aq.pLast = &u.aq.pData0[u.aq.nField-1];
   u.aq.file_format = p->minWriteFileFormat;
   nData = 0;         /* Number of bytes of data space */
   nHdr = 0;          /* Number of bytes of header space */
   nZero = 0;         /* Number of zero bytes at the end of the record */
   nField = pOp->p1;
   zAffinity = pOp->p4.z;
   assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem-p->nCursor)+1 );
   pData0 = &aMem[nField];
   nField = pOp->p2;
   pLast = &pData0[nField-1];
   file_format = p->minWriteFileFormat;
   /* Identify the output register */
   assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
   pOut = &aMem[pOp->p3];
   memAboutToChange(p, pOut);
   /* Apply the requested affinity to all inputs
   */
   assert( pData0<=pLast );
   if( zAffinity ){
     pRec = pData0;
     do{
       applyAffinity(pRec++, *(zAffinity++), encoding);
       assert( zAffinity[0]==0 || pRec<=pLast );
     }while( zAffinity[0] );
   }
   /* Loop through the elements that will make up the record to figure
   ** out how much space is required for the new record.
   */
   for(u.aq.pRec=u.aq.pData0; u.aq.pRec<=u.aq.pLast; u.aq.pRec++){
     assert( memIsValid(u.aq.pRec) );
     if( u.aq.zAffinity ){
       applyAffinity(u.aq.pRec, u.aq.zAffinity[u.aq.pRec-u.aq.pData0], encoding);
     }
     if( u.aq.pRec->flags&MEM_Zero && u.aq.pRec->n>0 ){
       sqlite3VdbeMemExpandBlob(u.aq.pRec);
     }
     u.aq.serial_type = sqlite3VdbeSerialType(u.aq.pRec, u.aq.file_format);
     u.aq.len = sqlite3VdbeSerialTypeLen(u.aq.serial_type);
     u.aq.nData += u.aq.len;
     u.aq.nHdr += sqlite3VarintLen(u.aq.serial_type);
     if( u.aq.pRec->flags & MEM_Zero ){
       /* Only pure zero-filled BLOBs can be input to this Opcode.
       ** We do not allow blobs with a prefix and a zero-filled tail. */
       u.aq.nZero += u.aq.pRec->u.nZero;
     }else if( u.aq.len ){
       u.aq.nZero = 0;
   pRec = pLast;
   do{
     assert( memIsValid(pRec) );
     serial_type = sqlite3VdbeSerialType(pRec, file_format);
     len = sqlite3VdbeSerialTypeLen(serial_type);
     if( pRec->flags & MEM_Zero ){
       if( nData ){
         sqlite3VdbeMemExpandBlob(pRec);
       }else{
         nZero += pRec->u.nZero;
         len -= pRec->u.nZero;
       }
     }
   }
     nData += len;
     testcase( serial_type==127 );
     testcase( serial_type==128 );
     nHdr += serial_type<=127 ? 1 : sqlite3VarintLen(serial_type);
   }while( (--pRec)>=pData0 );
   /* Add the initial header varint and total the size */
   u.aq.nHdr += u.aq.nVarint = sqlite3VarintLen(u.aq.nHdr);
   if( u.aq.nVarint<sqlite3VarintLen(u.aq.nHdr) ){
     u.aq.nHdr++;
   }
   u.aq.nByte = u.aq.nHdr+u.aq.nData-u.aq.nZero;
   if( u.aq.nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
   testcase( nHdr==126 );
   testcase( nHdr==127 );
   if( nHdr<=126 ){
     /* The common case */
     nHdr += 1;
   }else{
     /* Rare case of a really large header */
     nVarint = sqlite3VarintLen(nHdr);
     nHdr += nVarint;
     if( nVarint<sqlite3VarintLen(nHdr) ) nHdr++;
   }
   nByte = nHdr+nData;
   if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
     goto too_big;
   }
   /* Make sure the output register has a buffer large enough to store
   /* Make sure the output register has a buffer large enough to store
   ** the new record. The output register (pOp->p3) is not allowed to
   ** be one of the input registers (because the following call to
   ** sqlite3VdbeMemGrow() could clobber the value before it is used).
   */
   if( sqlite3VdbeMemGrow(pOut, (int)u.aq.nByte, 0) ){
   if( sqlite3VdbeMemGrow(pOut, (int)nByte, 0) ){
     goto no_mem;
   }
   u.aq.zNewRecord = (u8 *)pOut->z;
   zNewRecord = (u8 *)pOut->z;
   /* Write the record */
   u.aq.i = putVarint32(u.aq.zNewRecord, u.aq.nHdr);
   for(u.aq.pRec=u.aq.pData0; u.aq.pRec<=u.aq.pLast; u.aq.pRec++){
     u.aq.serial_type = sqlite3VdbeSerialType(u.aq.pRec, u.aq.file_format);
     u.aq.i += putVarint32(&u.aq.zNewRecord[u.aq.i], u.aq.serial_type);      /* serial type */
   }
   for(u.aq.pRec=u.aq.pData0; u.aq.pRec<=u.aq.pLast; u.aq.pRec++){  /* serial data */
     u.aq.i += sqlite3VdbeSerialPut(&u.aq.zNewRecord[u.aq.i], (int)(u.aq.nByte-u.aq.i), u.aq.pRec,u.aq.file_format);
   }
   assert( u.aq.i==u.aq.nByte );
   i = putVarint32(zNewRecord, nHdr);
   j = nHdr;
   assert( pData0<=pLast );
   pRec = pData0;
   do{
     serial_type = sqlite3VdbeSerialType(pRec, file_format);
     i += putVarint32(&zNewRecord[i], serial_type);            /* serial type */
     j += sqlite3VdbeSerialPut(&zNewRecord[j], pRec, serial_type); /* content */
   }while( (++pRec)<=pLast );
   assert( i==nHdr );
   assert( j==nByte );
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   pOut->n = (int)u.aq.nByte;
   pOut->flags = MEM_Blob | MEM_Dyn;
   pOut->n = (int)nByte;
   pOut->flags = MEM_Blob;
   pOut->xDel = 0;
   if( u.aq.nZero ){
     pOut->u.nZero = u.aq.nZero;
   if( nZero ){
     pOut->u.nZero = nZero;
     pOut->flags |= MEM_Zero;
   }
   pOut->enc = SQLITE_UTF8;  /* In case the blob is ever converted to text */

@@ -68804,24 +69794,21 @@ case OP_MakeRecord: {

 }
 /* Opcode: Count P1 P2 * * *
 ** Synopsis: r[P2]=count()
 **
 ** Store the number of entries (an integer value) in the table or index
 ** opened by cursor P1 in register P2
 */
 #ifndef SQLITE_OMIT_BTREECOUNT
 case OP_Count: {         /* out2-prerelease */
 #if 0  /* local variables moved into u.ar */
   i64 nEntry;
   BtCursor *pCrsr;
 #endif /* local variables moved into u.ar */
   u.ar.pCrsr = p->apCsr[pOp->p1]->pCursor;
   if( ALWAYS(u.ar.pCrsr) ){
     rc = sqlite3BtreeCount(u.ar.pCrsr, &u.ar.nEntry);
   }else{
     u.ar.nEntry = 0;
   }
   pOut->u.i = u.ar.nEntry;
   pCrsr = p->apCsr[pOp->p1]->pCursor;
   assert( pCrsr );
   nEntry = 0;  /* Not needed.  Only used to silence a warning. */
   rc = sqlite3BtreeCount(pCrsr, &nEntry);
   pOut->u.i = nEntry;
   break;
 }
 #endif

@@ -68833,7 +69820,6 @@ case OP_Count: { /* out2-prerelease */

 ** existing savepoint, P1==1, or to rollback an existing savepoint P1==2.
 */
 case OP_Savepoint: {
 #if 0  /* local variables moved into u.as */
   int p1;                         /* Value of P1 operand */
   char *zName;                    /* Name of savepoint */
   int nName;

@@ -68842,30 +69828,29 @@ case OP_Savepoint: {

   Savepoint *pTmp;
   int iSavepoint;
   int ii;
 #endif /* local variables moved into u.as */
   u.as.p1 = pOp->p1;
   u.as.zName = pOp->p4.z;
   p1 = pOp->p1;
   zName = pOp->p4.z;
   /* Assert that the u.as.p1 parameter is valid. Also that if there is no open
   ** transaction, then there cannot be any savepoints.
   /* Assert that the p1 parameter is valid. Also that if there is no open
   ** transaction, then there cannot be any savepoints.
   */
   assert( db->pSavepoint==0 || db->autoCommit==0 );
   assert( u.as.p1==SAVEPOINT_BEGIN||u.as.p1==SAVEPOINT_RELEASE||u.as.p1==SAVEPOINT_ROLLBACK );
   assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK );
   assert( db->pSavepoint || db->isTransactionSavepoint==0 );
   assert( checkSavepointCount(db) );
   assert( p->bIsReader );
   if( u.as.p1==SAVEPOINT_BEGIN ){
   if( p1==SAVEPOINT_BEGIN ){
     if( db->nVdbeWrite>0 ){
       /* A new savepoint cannot be created if there are active write
       /* A new savepoint cannot be created if there are active write
       ** statements (i.e. open read/write incremental blob handles).
       */
       sqlite3SetString(&p->zErrMsg, db, "cannot open savepoint - "
         "SQL statements in progress");
       rc = SQLITE_BUSY;
     }else{
       u.as.nName = sqlite3Strlen30(u.as.zName);
       nName = sqlite3Strlen30(zName);
 #ifndef SQLITE_OMIT_VIRTUALTABLE
       /* This call is Ok even if this savepoint is actually a transaction

@@ -68879,11 +69864,11 @@ case OP_Savepoint: {

 #endif
       /* Create a new savepoint structure. */
       u.as.pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+u.as.nName+1);
       if( u.as.pNew ){
         u.as.pNew->zName = (char *)&u.as.pNew[1];
         memcpy(u.as.pNew->zName, u.as.zName, u.as.nName+1);
       pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+nName+1);
       if( pNew ){
         pNew->zName = (char *)&pNew[1];
         memcpy(pNew->zName, zName, nName+1);
         /* If there is no open transaction, then mark this as a special
         ** "transaction savepoint". */
         if( db->autoCommit ){

@@ -68892,45 +69877,45 @@ case OP_Savepoint: {

         }else{
           db->nSavepoint++;
         }
         /* Link the new savepoint into the database handle's list. */
         u.as.pNew->pNext = db->pSavepoint;
         db->pSavepoint = u.as.pNew;
         u.as.pNew->nDeferredCons = db->nDeferredCons;
         u.as.pNew->nDeferredImmCons = db->nDeferredImmCons;
         pNew->pNext = db->pSavepoint;
         db->pSavepoint = pNew;
         pNew->nDeferredCons = db->nDeferredCons;
         pNew->nDeferredImmCons = db->nDeferredImmCons;
       }
     }
   }else{
     u.as.iSavepoint = 0;
     iSavepoint = 0;
     /* Find the named savepoint. If there is no such savepoint, then an
     ** an error is returned to the user.  */
     for(
       u.as.pSavepoint = db->pSavepoint;
       u.as.pSavepoint && sqlite3StrICmp(u.as.pSavepoint->zName, u.as.zName);
       u.as.pSavepoint = u.as.pSavepoint->pNext
       pSavepoint = db->pSavepoint;
       pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
       pSavepoint = pSavepoint->pNext
     ){
       u.as.iSavepoint++;
       iSavepoint++;
     }
     if( !u.as.pSavepoint ){
       sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", u.as.zName);
     if( !pSavepoint ){
       sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", zName);
       rc = SQLITE_ERROR;
     }else if( db->nVdbeWrite>0 && u.as.p1==SAVEPOINT_RELEASE ){
       /* It is not possible to release (commit) a savepoint if there are
     }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){
       /* It is not possible to release (commit) a savepoint if there are
       ** active write statements.
       */
       sqlite3SetString(&p->zErrMsg, db,
       sqlite3SetString(&p->zErrMsg, db,
         "cannot release savepoint - SQL statements in progress"
       );
       rc = SQLITE_BUSY;
     }else{
       /* Determine whether or not this is a transaction savepoint. If so,
       ** and this is a RELEASE command, then the current transaction
       ** is committed.
       ** and this is a RELEASE command, then the current transaction
       ** is committed.
       */
       int isTransaction = u.as.pSavepoint->pNext==0 && db->isTransactionSavepoint;
       if( isTransaction && u.as.p1==SAVEPOINT_RELEASE ){
       int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint;
       if( isTransaction && p1==SAVEPOINT_RELEASE ){
         if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
           goto vdbe_return;
         }

@@ -68944,52 +69929,52 @@ case OP_Savepoint: {

         db->isTransactionSavepoint = 0;
         rc = p->rc;
       }else{
         u.as.iSavepoint = db->nSavepoint - u.as.iSavepoint - 1;
         if( u.as.p1==SAVEPOINT_ROLLBACK ){
           for(u.as.ii=0; u.as.ii<db->nDb; u.as.ii++){
             sqlite3BtreeTripAllCursors(db->aDb[u.as.ii].pBt, SQLITE_ABORT);
         iSavepoint = db->nSavepoint - iSavepoint - 1;
         if( p1==SAVEPOINT_ROLLBACK ){
           for(ii=0; ii<db->nDb; ii++){
             sqlite3BtreeTripAllCursors(db->aDb[ii].pBt, SQLITE_ABORT);
           }
         }
         for(u.as.ii=0; u.as.ii<db->nDb; u.as.ii++){
           rc = sqlite3BtreeSavepoint(db->aDb[u.as.ii].pBt, u.as.p1, u.as.iSavepoint);
         for(ii=0; ii<db->nDb; ii++){
           rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
           if( rc!=SQLITE_OK ){
             goto abort_due_to_error;
           }
         }
         if( u.as.p1==SAVEPOINT_ROLLBACK && (db->flags&SQLITE_InternChanges)!=0 ){
         if( p1==SAVEPOINT_ROLLBACK && (db->flags&SQLITE_InternChanges)!=0 ){
           sqlite3ExpirePreparedStatements(db);
           sqlite3ResetAllSchemasOfConnection(db);
           db->flags = (db->flags | SQLITE_InternChanges);
         }
       }
       /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
       /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
       ** savepoints nested inside of the savepoint being operated on. */
       while( db->pSavepoint!=u.as.pSavepoint ){
         u.as.pTmp = db->pSavepoint;
         db->pSavepoint = u.as.pTmp->pNext;
         sqlite3DbFree(db, u.as.pTmp);
       while( db->pSavepoint!=pSavepoint ){
         pTmp = db->pSavepoint;
         db->pSavepoint = pTmp->pNext;
         sqlite3DbFree(db, pTmp);
         db->nSavepoint--;
       }
       /* If it is a RELEASE, then destroy the savepoint being operated on
       ** too. If it is a ROLLBACK TO, then set the number of deferred
       /* If it is a RELEASE, then destroy the savepoint being operated on
       ** too. If it is a ROLLBACK TO, then set the number of deferred
       ** constraint violations present in the database to the value stored
       ** when the savepoint was created.  */
       if( u.as.p1==SAVEPOINT_RELEASE ){
         assert( u.as.pSavepoint==db->pSavepoint );
         db->pSavepoint = u.as.pSavepoint->pNext;
         sqlite3DbFree(db, u.as.pSavepoint);
       if( p1==SAVEPOINT_RELEASE ){
         assert( pSavepoint==db->pSavepoint );
         db->pSavepoint = pSavepoint->pNext;
         sqlite3DbFree(db, pSavepoint);
         if( !isTransaction ){
           db->nSavepoint--;
         }
       }else{
         db->nDeferredCons = u.as.pSavepoint->nDeferredCons;
         db->nDeferredImmCons = u.as.pSavepoint->nDeferredImmCons;
         db->nDeferredCons = pSavepoint->nDeferredCons;
         db->nDeferredImmCons = pSavepoint->nDeferredImmCons;
       }
       if( !isTransaction ){
         rc = sqlite3VtabSavepoint(db, u.as.p1, u.as.iSavepoint);
         rc = sqlite3VtabSavepoint(db, p1, iSavepoint);
         if( rc!=SQLITE_OK ) goto abort_due_to_error;
       }
     }

@@ -69008,50 +69993,48 @@ case OP_Savepoint: {

 ** This instruction causes the VM to halt.
 */
 case OP_AutoCommit: {
 #if 0  /* local variables moved into u.at */
   int desiredAutoCommit;
   int iRollback;
   int turnOnAC;
 #endif /* local variables moved into u.at */
   u.at.desiredAutoCommit = pOp->p1;
   u.at.iRollback = pOp->p2;
   u.at.turnOnAC = u.at.desiredAutoCommit && !db->autoCommit;
   assert( u.at.desiredAutoCommit==1 || u.at.desiredAutoCommit==0 );
   assert( u.at.desiredAutoCommit==1 || u.at.iRollback==0 );
   desiredAutoCommit = pOp->p1;
   iRollback = pOp->p2;
   turnOnAC = desiredAutoCommit && !db->autoCommit;
   assert( desiredAutoCommit==1 || desiredAutoCommit==0 );
   assert( desiredAutoCommit==1 || iRollback==0 );
   assert( db->nVdbeActive>0 );  /* At least this one VM is active */
   assert( p->bIsReader );
 #if 0
   if( u.at.turnOnAC && u.at.iRollback && db->nVdbeActive>1 ){
   if( turnOnAC && iRollback && db->nVdbeActive>1 ){
     /* If this instruction implements a ROLLBACK and other VMs are
     ** still running, and a transaction is active, return an error indicating
     ** that the other VMs must complete first.
     ** that the other VMs must complete first.
     */
     sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
         "SQL statements in progress");
     rc = SQLITE_BUSY;
   }else
 #endif
   if( u.at.turnOnAC && !u.at.iRollback && db->nVdbeWrite>0 ){
   if( turnOnAC && !iRollback && db->nVdbeWrite>0 ){
     /* If this instruction implements a COMMIT and other VMs are writing
     ** return an error indicating that the other VMs must complete first.
     ** return an error indicating that the other VMs must complete first.
     */
     sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
         "SQL statements in progress");
     rc = SQLITE_BUSY;
   }else if( u.at.desiredAutoCommit!=db->autoCommit ){
     if( u.at.iRollback ){
       assert( u.at.desiredAutoCommit==1 );
   }else if( desiredAutoCommit!=db->autoCommit ){
     if( iRollback ){
       assert( desiredAutoCommit==1 );
       sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
       db->autoCommit = 1;
     }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
       goto vdbe_return;
     }else{
       db->autoCommit = (u8)u.at.desiredAutoCommit;
       db->autoCommit = (u8)desiredAutoCommit;
       if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
         p->pc = pc;
         db->autoCommit = (u8)(1-u.at.desiredAutoCommit);
         db->autoCommit = (u8)(1-desiredAutoCommit);
         p->rc = rc = SQLITE_BUSY;
         goto vdbe_return;
       }

@@ -69066,34 +70049,28 @@ case OP_AutoCommit: {

     goto vdbe_return;
   }else{
     sqlite3SetString(&p->zErrMsg, db,
         (!u.at.desiredAutoCommit)?"cannot start a transaction within a transaction":(
         (u.at.iRollback)?"cannot rollback - no transaction is active":
         (!desiredAutoCommit)?"cannot start a transaction within a transaction":(
         (iRollback)?"cannot rollback - no transaction is active":
                    "cannot commit - no transaction is active"));
     rc = SQLITE_ERROR;
   }
   break;
 }
 /* Opcode: Transaction P1 P2 * * *
 /* Opcode: Transaction P1 P2 P3 P4 P5
 **
 ** Begin a transaction.  The transaction ends when a Commit or Rollback
 ** opcode is encountered.  Depending on the ON CONFLICT setting, the
 ** transaction might also be rolled back if an error is encountered.
 ** Begin a transaction on database P1 if a transaction is not already
 ** active.
 ** If P2 is non-zero, then a write-transaction is started, or if a
 ** read-transaction is already active, it is upgraded to a write-transaction.
 ** If P2 is zero, then a read-transaction is started.
 **
 ** P1 is the index of the database file on which the transaction is
 ** started.  Index 0 is the main database file and index 1 is the
 ** file used for temporary tables.  Indices of 2 or more are used for
 ** attached databases.
 **
 ** If P2 is non-zero, then a write-transaction is started.  A RESERVED lock is
 ** obtained on the database file when a write-transaction is started.  No
 ** other process can start another write transaction while this transaction is
 ** underway.  Starting a write transaction also creates a rollback journal. A
 ** write transaction must be started before any changes can be made to the
 ** database.  If P2 is greater than or equal to 2 then an EXCLUSIVE lock is
 ** also obtained on the file.
 **
 ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
 ** true (this flag is set if the Vdbe may modify more than one row and may
 ** throw an ABORT exception), a statement transaction may also be opened.

@@ -69104,12 +70081,21 @@ case OP_AutoCommit: {

 ** entire transaction. If no error is encountered, the statement transaction
 ** will automatically commit when the VDBE halts.
 **
 ** If P2 is zero, then a read-lock is obtained on the database file.
 ** If P5!=0 then this opcode also checks the schema cookie against P3
 ** and the schema generation counter against P4.
 ** The cookie changes its value whenever the database schema changes.
 ** This operation is used to detect when that the cookie has changed
 ** and that the current process needs to reread the schema.  If the schema
 ** cookie in P3 differs from the schema cookie in the database header or
 ** if the schema generation counter in P4 differs from the current
 ** generation counter, then an SQLITE_SCHEMA error is raised and execution
 ** halts.  The sqlite3_step() wrapper function might then reprepare the
 ** statement and rerun it from the beginning.
 */
 case OP_Transaction: {
 #if 0  /* local variables moved into u.au */
   Btree *pBt;
 #endif /* local variables moved into u.au */
   int iMeta;
   int iGen;
   assert( p->bIsReader );
   assert( p->readOnly==0 || pOp->p2==0 );

@@ -69119,10 +70105,10 @@ case OP_Transaction: {

     rc = SQLITE_READONLY;
     goto abort_due_to_error;
   }
   u.au.pBt = db->aDb[pOp->p1].pBt;
   pBt = db->aDb[pOp->p1].pBt;
   if( u.au.pBt ){
     rc = sqlite3BtreeBeginTrans(u.au.pBt, pOp->p2);
   if( pBt ){
     rc = sqlite3BtreeBeginTrans(pBt, pOp->p2);
     if( rc==SQLITE_BUSY ){
       p->pc = pc;
       p->rc = rc = SQLITE_BUSY;

@@ -69132,19 +70118,19 @@ case OP_Transaction: {

       goto abort_due_to_error;
     }
     if( pOp->p2 && p->usesStmtJournal
      && (db->autoCommit==0 || db->nVdbeRead>1)
     if( pOp->p2 && p->usesStmtJournal
      && (db->autoCommit==0 || db->nVdbeRead>1)
     ){
       assert( sqlite3BtreeIsInTrans(u.au.pBt) );
       assert( sqlite3BtreeIsInTrans(pBt) );
       if( p->iStatement==0 ){
         assert( db->nStatement>=0 && db->nSavepoint>=0 );
         db->nStatement++;
         db->nStatement++;
         p->iStatement = db->nSavepoint + db->nStatement;
       }
       rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
       if( rc==SQLITE_OK ){
         rc = sqlite3BtreeBeginStmt(u.au.pBt, p->iStatement);
         rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
       }
       /* Store the current value of the database handles deferred constraint

@@ -69153,6 +70139,35 @@ case OP_Transaction: {

       p->nStmtDefCons = db->nDeferredCons;
       p->nStmtDefImmCons = db->nDeferredImmCons;
     }
     /* Gather the schema version number for checking */
     sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&iMeta);
     iGen = db->aDb[pOp->p1].pSchema->iGeneration;
   }else{
     iGen = iMeta = 0;
   }
   assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
   if( pOp->p5 && (iMeta!=pOp->p3 || iGen!=pOp->p4.i) ){
     sqlite3DbFree(db, p->zErrMsg);
     p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
     /* If the schema-cookie from the database file matches the cookie
     ** stored with the in-memory representation of the schema, do
     ** not reload the schema from the database file.
     **
     ** If virtual-tables are in use, this is not just an optimization.
     ** Often, v-tables store their data in other SQLite tables, which
     ** are queried from within xNext() and other v-table methods using
     ** prepared queries. If such a query is out-of-date, we do not want to
     ** discard the database schema, as the user code implementing the
     ** v-table would have to be ready for the sqlite3_vtab structure itself
     ** to be invalidated whenever sqlite3_step() is called from within
     ** a v-table method.
     */
     if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
       sqlite3ResetOneSchema(db, pOp->p1);
     }
     p->expired = 1;
     rc = SQLITE_SCHEMA;
   }
   break;
 }

@@ -69170,22 +70185,20 @@ case OP_Transaction: {

 ** executing this instruction.
 */
 case OP_ReadCookie: {               /* out2-prerelease */
 #if 0  /* local variables moved into u.av */
   int iMeta;
   int iDb;
   int iCookie;
 #endif /* local variables moved into u.av */
   assert( p->bIsReader );
   u.av.iDb = pOp->p1;
   u.av.iCookie = pOp->p3;
   iDb = pOp->p1;
   iCookie = pOp->p3;
   assert( pOp->p3<SQLITE_N_BTREE_META );
   assert( u.av.iDb>=0 && u.av.iDb<db->nDb );
   assert( db->aDb[u.av.iDb].pBt!=0 );
   assert( (p->btreeMask & (((yDbMask)1)<<u.av.iDb))!=0 );
   assert( iDb>=0 && iDb<db->nDb );
   assert( db->aDb[iDb].pBt!=0 );
   assert( (p->btreeMask & (((yDbMask)1)<<iDb))!=0 );
   sqlite3BtreeGetMeta(db->aDb[u.av.iDb].pBt, u.av.iCookie, (u32 *)&u.av.iMeta);
   pOut->u.i = u.av.iMeta;
   sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
   pOut->u.i = iMeta;
   break;
 }

@@ -69200,27 +70213,25 @@ case OP_ReadCookie: { /* out2-prerelease */

 ** A transaction must be started before executing this opcode.
 */
 case OP_SetCookie: {       /* in3 */
 #if 0  /* local variables moved into u.aw */
   Db *pDb;
 #endif /* local variables moved into u.aw */
   assert( pOp->p2<SQLITE_N_BTREE_META );
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
   assert( p->readOnly==0 );
   u.aw.pDb = &db->aDb[pOp->p1];
   assert( u.aw.pDb->pBt!=0 );
   pDb = &db->aDb[pOp->p1];
   assert( pDb->pBt!=0 );
   assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
   pIn3 = &aMem[pOp->p3];
   sqlite3VdbeMemIntegerify(pIn3);
   /* See note about index shifting on OP_ReadCookie */
   rc = sqlite3BtreeUpdateMeta(u.aw.pDb->pBt, pOp->p2, (int)pIn3->u.i);
   rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, (int)pIn3->u.i);
   if( pOp->p2==BTREE_SCHEMA_VERSION ){
     /* When the schema cookie changes, record the new cookie internally */
     u.aw.pDb->pSchema->schema_cookie = (int)pIn3->u.i;
     pDb->pSchema->schema_cookie = (int)pIn3->u.i;
     db->flags |= SQLITE_InternChanges;
   }else if( pOp->p2==BTREE_FILE_FORMAT ){
     /* Record changes in the file format */
     u.aw.pDb->pSchema->file_format = (u8)pIn3->u.i;
     pDb->pSchema->file_format = (u8)pIn3->u.i;
   }
   if( pOp->p1==1 ){
     /* Invalidate all prepared statements whenever the TEMP database

@@ -69231,69 +70242,8 @@ case OP_SetCookie: { /* in3 */

   break;
 }
 /* Opcode: VerifyCookie P1 P2 P3 * *
 **
 ** Check the value of global database parameter number 0 (the
 ** schema version) and make sure it is equal to P2 and that the
 ** generation counter on the local schema parse equals P3.
 **
 ** P1 is the database number which is 0 for the main database file
 ** and 1 for the file holding temporary tables and some higher number
 ** for auxiliary databases.
 **
 ** The cookie changes its value whenever the database schema changes.
 ** This operation is used to detect when that the cookie has changed
 ** and that the current process needs to reread the schema.
 **
 ** Either a transaction needs to have been started or an OP_Open needs
 ** to be executed (to establish a read lock) before this opcode is
 ** invoked.
 */
 case OP_VerifyCookie: {
 #if 0  /* local variables moved into u.ax */
   int iMeta;
   int iGen;
   Btree *pBt;
 #endif /* local variables moved into u.ax */
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
   assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
   assert( p->bIsReader );
   u.ax.pBt = db->aDb[pOp->p1].pBt;
   if( u.ax.pBt ){
     sqlite3BtreeGetMeta(u.ax.pBt, BTREE_SCHEMA_VERSION, (u32 *)&u.ax.iMeta);
     u.ax.iGen = db->aDb[pOp->p1].pSchema->iGeneration;
   }else{
     u.ax.iGen = u.ax.iMeta = 0;
   }
   if( u.ax.iMeta!=pOp->p2 || u.ax.iGen!=pOp->p3 ){
     sqlite3DbFree(db, p->zErrMsg);
     p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
     /* If the schema-cookie from the database file matches the cookie
     ** stored with the in-memory representation of the schema, do
     ** not reload the schema from the database file.
     **
     ** If virtual-tables are in use, this is not just an optimization.
     ** Often, v-tables store their data in other SQLite tables, which
     ** are queried from within xNext() and other v-table methods using
     ** prepared queries. If such a query is out-of-date, we do not want to
     ** discard the database schema, as the user code implementing the
     ** v-table would have to be ready for the sqlite3_vtab structure itself
     ** to be invalidated whenever sqlite3_step() is called from within
     ** a v-table method.
     */
     if( db->aDb[pOp->p1].pSchema->schema_cookie!=u.ax.iMeta ){
       sqlite3ResetOneSchema(db, pOp->p1);
     }
     p->expired = 1;
     rc = SQLITE_SCHEMA;
   }
   break;
 }
 /* Opcode: OpenRead P1 P2 P3 P4 P5
 ** Synopsis: root=P2 iDb=P3
 **
 ** Open a read-only cursor for the database table whose root page is
 ** P2 in a database file.  The database file is determined by P3.

@@ -69324,6 +70274,7 @@ case OP_VerifyCookie: {

 ** See also OpenWrite.
 */
 /* Opcode: OpenWrite P1 P2 P3 P4 P5
 ** Synopsis: root=P2 iDb=P3
 **
 ** Open a read/write cursor named P1 on the table or index whose root
 ** page is P2.  Or if P5!=0 use the content of register P2 to find the

@@ -69344,7 +70295,6 @@ case OP_VerifyCookie: {

 */
 case OP_OpenRead:
 case OP_OpenWrite: {
 #if 0  /* local variables moved into u.ay */
   int nField;
   KeyInfo *pKeyInfo;
   int p2;

@@ -69353,7 +70303,6 @@ case OP_OpenWrite: {

   Btree *pX;
   VdbeCursor *pCur;
   Db *pDb;
 #endif /* local variables moved into u.ay */
   assert( (pOp->p5&(OPFLAG_P2ISREG|OPFLAG_BULKCSR))==pOp->p5 );
   assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 );

@@ -69365,72 +70314,75 @@ case OP_OpenWrite: {

     break;
   }
   u.ay.nField = 0;
   u.ay.pKeyInfo = 0;
   u.ay.p2 = pOp->p2;
   u.ay.iDb = pOp->p3;
   assert( u.ay.iDb>=0 && u.ay.iDb<db->nDb );
   assert( (p->btreeMask & (((yDbMask)1)<<u.ay.iDb))!=0 );
   u.ay.pDb = &db->aDb[u.ay.iDb];
   u.ay.pX = u.ay.pDb->pBt;
   assert( u.ay.pX!=0 );
   nField = 0;
   pKeyInfo = 0;
   p2 = pOp->p2;
   iDb = pOp->p3;
   assert( iDb>=0 && iDb<db->nDb );
   assert( (p->btreeMask & (((yDbMask)1)<<iDb))!=0 );
   pDb = &db->aDb[iDb];
   pX = pDb->pBt;
   assert( pX!=0 );
   if( pOp->opcode==OP_OpenWrite ){
     u.ay.wrFlag = 1;
     assert( sqlite3SchemaMutexHeld(db, u.ay.iDb, 0) );
     if( u.ay.pDb->pSchema->file_format < p->minWriteFileFormat ){
       p->minWriteFileFormat = u.ay.pDb->pSchema->file_format;
     wrFlag = 1;
     assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
     if( pDb->pSchema->file_format < p->minWriteFileFormat ){
       p->minWriteFileFormat = pDb->pSchema->file_format;
     }
   }else{
     u.ay.wrFlag = 0;
     wrFlag = 0;
   }
   if( pOp->p5 & OPFLAG_P2ISREG ){
     assert( u.ay.p2>0 );
     assert( u.ay.p2<=(p->nMem-p->nCursor) );
     pIn2 = &aMem[u.ay.p2];
     assert( p2>0 );
     assert( p2<=(p->nMem-p->nCursor) );
     pIn2 = &aMem[p2];
     assert( memIsValid(pIn2) );
     assert( (pIn2->flags & MEM_Int)!=0 );
     sqlite3VdbeMemIntegerify(pIn2);
     u.ay.p2 = (int)pIn2->u.i;
     /* The u.ay.p2 value always comes from a prior OP_CreateTable opcode and
     ** that opcode will always set the u.ay.p2 value to 2 or more or else fail.
     p2 = (int)pIn2->u.i;
     /* The p2 value always comes from a prior OP_CreateTable opcode and
     ** that opcode will always set the p2 value to 2 or more or else fail.
     ** If there were a failure, the prepared statement would have halted
     ** before reaching this instruction. */
     if( NEVER(u.ay.p2<2) ) {
     if( NEVER(p2<2) ) {
       rc = SQLITE_CORRUPT_BKPT;
       goto abort_due_to_error;
     }
   }
   if( pOp->p4type==P4_KEYINFO ){
     u.ay.pKeyInfo = pOp->p4.pKeyInfo;
     u.ay.pKeyInfo->enc = ENC(p->db);
     u.ay.nField = u.ay.pKeyInfo->nField+1;
     pKeyInfo = pOp->p4.pKeyInfo;
     assert( pKeyInfo->enc==ENC(db) );
     assert( pKeyInfo->db==db );
     nField = pKeyInfo->nField+pKeyInfo->nXField;
   }else if( pOp->p4type==P4_INT32 ){
     u.ay.nField = pOp->p4.i;
     nField = pOp->p4.i;
   }
   assert( pOp->p1>=0 );
   u.ay.pCur = allocateCursor(p, pOp->p1, u.ay.nField, u.ay.iDb, 1);
   if( u.ay.pCur==0 ) goto no_mem;
   u.ay.pCur->nullRow = 1;
   u.ay.pCur->isOrdered = 1;
   rc = sqlite3BtreeCursor(u.ay.pX, u.ay.p2, u.ay.wrFlag, u.ay.pKeyInfo, u.ay.pCur->pCursor);
   u.ay.pCur->pKeyInfo = u.ay.pKeyInfo;
   assert( nField>=0 );
   testcase( nField==0 );  /* Table with INTEGER PRIMARY KEY and nothing else */
   pCur = allocateCursor(p, pOp->p1, nField, iDb, 1);
   if( pCur==0 ) goto no_mem;
   pCur->nullRow = 1;
   pCur->isOrdered = 1;
   rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->pCursor);
   pCur->pKeyInfo = pKeyInfo;
   assert( OPFLAG_BULKCSR==BTREE_BULKLOAD );
   sqlite3BtreeCursorHints(u.ay.pCur->pCursor, (pOp->p5 & OPFLAG_BULKCSR));
   sqlite3BtreeCursorHints(pCur->pCursor, (pOp->p5 & OPFLAG_BULKCSR));
   /* Since it performs no memory allocation or IO, the only value that
   ** sqlite3BtreeCursor() may return is SQLITE_OK. */
   assert( rc==SQLITE_OK );
   /* Set the VdbeCursor.isTable and isIndex variables. Previous versions of
   /* Set the VdbeCursor.isTable variable. Previous versions of
   ** SQLite used to check if the root-page flags were sane at this point
   ** and report database corruption if they were not, but this check has
   ** since moved into the btree layer.  */
   u.ay.pCur->isTable = pOp->p4type!=P4_KEYINFO;
   u.ay.pCur->isIndex = !u.ay.pCur->isTable;
   ** since moved into the btree layer.  */
   pCur->isTable = pOp->p4type!=P4_KEYINFO;
   break;
 }
 /* Opcode: OpenEphemeral P1 P2 * P4 P5
 ** Synopsis: nColumn=P2
 **
 ** Open a new cursor P1 to a transient table.
 ** The cursor is always opened read/write even if

@@ -69442,18 +70394,13 @@ case OP_OpenWrite: {

 ** if P4 is not 0.  If P4 is not NULL, it points to a KeyInfo structure
 ** that defines the format of keys in the index.
 **
 ** This opcode was once called OpenTemp.  But that created
 ** confusion because the term "temp table", might refer either
 ** to a TEMP table at the SQL level, or to a table opened by
 ** this opcode.  Then this opcode was call OpenVirtual.  But
 ** that created confusion with the whole virtual-table idea.
 **
 ** The P5 parameter can be a mask of the BTREE_* flags defined
 ** in btree.h.  These flags control aspects of the operation of
 ** the btree.  The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
 ** added automatically.
 */
 /* Opcode: OpenAutoindex P1 P2 * P4 *
 ** Synopsis: nColumn=P2
 **
 ** This opcode works the same as OP_OpenEphemeral.  It has a
 ** different name to distinguish its use.  Tables created using

@@ -69462,24 +70409,24 @@ case OP_OpenWrite: {

 */
 case OP_OpenAutoindex:
 case OP_OpenEphemeral: {
 #if 0  /* local variables moved into u.az */
   VdbeCursor *pCx;
 #endif /* local variables moved into u.az */
   static const int vfsFlags =
   KeyInfo *pKeyInfo;
   static const int vfsFlags =
       SQLITE_OPEN_READWRITE |
       SQLITE_OPEN_CREATE |
       SQLITE_OPEN_EXCLUSIVE |
       SQLITE_OPEN_DELETEONCLOSE |
       SQLITE_OPEN_TRANSIENT_DB;
   assert( pOp->p1>=0 );
   u.az.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
   if( u.az.pCx==0 ) goto no_mem;
   u.az.pCx->nullRow = 1;
   rc = sqlite3BtreeOpen(db->pVfs, 0, db, &u.az.pCx->pBt,
   assert( pOp->p2>=0 );
   pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
   if( pCx==0 ) goto no_mem;
   pCx->nullRow = 1;
   rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBt,
                         BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, vfsFlags);
   if( rc==SQLITE_OK ){
     rc = sqlite3BtreeBeginTrans(u.az.pCx->pBt, 1);
     rc = sqlite3BtreeBeginTrans(pCx->pBt, 1);
   }
   if( rc==SQLITE_OK ){
     /* If a transient index is required, create it by calling

@@ -69487,25 +70434,24 @@ case OP_OpenEphemeral: {

     ** opening it. If a transient table is required, just use the
     ** automatically created table with root-page 1 (an BLOB_INTKEY table).
     */
     if( pOp->p4.pKeyInfo ){
     if( (pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
       int pgno;
       assert( pOp->p4type==P4_KEYINFO );
       rc = sqlite3BtreeCreateTable(u.az.pCx->pBt, &pgno, BTREE_BLOBKEY | pOp->p5);
       rc = sqlite3BtreeCreateTable(pCx->pBt, &pgno, BTREE_BLOBKEY | pOp->p5);
       if( rc==SQLITE_OK ){
         assert( pgno==MASTER_ROOT+1 );
         rc = sqlite3BtreeCursor(u.az.pCx->pBt, pgno, 1,
                                 (KeyInfo*)pOp->p4.z, u.az.pCx->pCursor);
         u.az.pCx->pKeyInfo = pOp->p4.pKeyInfo;
         u.az.pCx->pKeyInfo->enc = ENC(p->db);
         assert( pKeyInfo->db==db );
         assert( pKeyInfo->enc==ENC(db) );
         pCx->pKeyInfo = pKeyInfo;
         rc = sqlite3BtreeCursor(pCx->pBt, pgno, 1, pKeyInfo, pCx->pCursor);
       }
       u.az.pCx->isTable = 0;
       pCx->isTable = 0;
     }else{
       rc = sqlite3BtreeCursor(u.az.pCx->pBt, MASTER_ROOT, 1, 0, u.az.pCx->pCursor);
       u.az.pCx->isTable = 1;
       rc = sqlite3BtreeCursor(pCx->pBt, MASTER_ROOT, 1, 0, pCx->pCursor);
       pCx->isTable = 1;
     }
   }
   u.az.pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
   u.az.pCx->isIndex = !u.az.pCx->isTable;
   pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
   break;
 }

@@ -69516,26 +70462,26 @@ case OP_OpenEphemeral: {

 ** tables using an external merge-sort algorithm.
 */
 case OP_SorterOpen: {
 #if 0  /* local variables moved into u.ba */
   VdbeCursor *pCx;
 #endif /* local variables moved into u.ba */
   u.ba.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
   if( u.ba.pCx==0 ) goto no_mem;
   u.ba.pCx->pKeyInfo = pOp->p4.pKeyInfo;
   u.ba.pCx->pKeyInfo->enc = ENC(p->db);
   u.ba.pCx->isSorter = 1;
   rc = sqlite3VdbeSorterInit(db, u.ba.pCx);
   assert( pOp->p1>=0 );
   assert( pOp->p2>=0 );
   pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
   if( pCx==0 ) goto no_mem;
   pCx->pKeyInfo = pOp->p4.pKeyInfo;
   assert( pCx->pKeyInfo->db==db );
   assert( pCx->pKeyInfo->enc==ENC(db) );
   rc = sqlite3VdbeSorterInit(db, pCx);
   break;
 }
 /* Opcode: OpenPseudo P1 P2 P3 * P5
 /* Opcode: OpenPseudo P1 P2 P3 * *
 ** Synopsis: P3 columns in r[P2]
 **
 ** Open a new cursor that points to a fake table that contains a single
 ** row of data.  The content of that one row in the content of memory
 ** register P2 when P5==0.  In other words, cursor P1 becomes an alias for the
 ** MEM_Blob content contained in register P2.  When P5==1, then the
 ** row is represented by P3 consecutive registers beginning with P2.
 ** row of data.  The content of that one row is the content of memory
 ** register P2.  In other words, cursor P1 becomes an alias for the
 ** MEM_Blob content contained in register P2.
 **
 ** A pseudo-table created by this opcode is used to hold a single
 ** row output from the sorter so that the row can be decomposed into

@@ -69546,18 +70492,16 @@ case OP_SorterOpen: {

 ** the pseudo-table.
 */
 case OP_OpenPseudo: {
 #if 0  /* local variables moved into u.bb */
   VdbeCursor *pCx;
 #endif /* local variables moved into u.bb */
   assert( pOp->p1>=0 );
   u.bb.pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, 0);
   if( u.bb.pCx==0 ) goto no_mem;
   u.bb.pCx->nullRow = 1;
   u.bb.pCx->pseudoTableReg = pOp->p2;
   u.bb.pCx->isTable = 1;
   u.bb.pCx->isIndex = 0;
   u.bb.pCx->multiPseudo = pOp->p5;
   assert( pOp->p3>=0 );
   pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, 0);
   if( pCx==0 ) goto no_mem;
   pCx->nullRow = 1;
   pCx->pseudoTableReg = pOp->p2;
   pCx->isTable = 1;
   assert( pOp->p5==0 );
   break;
 }

@@ -69574,6 +70518,7 @@ case OP_Close: {

 }
 /* Opcode: SeekGe P1 P2 P3 P4 *
 ** Synopsis: key=r[P3@P4]
 **
 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
 ** use the value in register P3 as the key.  If cursor P1 refers

@@ -69587,6 +70532,7 @@ case OP_Close: {

 ** See also: Found, NotFound, Distinct, SeekLt, SeekGt, SeekLe
 */
 /* Opcode: SeekGt P1 P2 P3 P4 *
 ** Synopsis: key=r[P3@P4]
 **
 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
 ** use the value in register P3 as a key. If cursor P1 refers

@@ -69600,6 +70546,7 @@ case OP_Close: {

 ** See also: Found, NotFound, Distinct, SeekLt, SeekGe, SeekLe
 */
 /* Opcode: SeekLt P1 P2 P3 P4 *
 ** Synopsis: key=r[P3@P4]
 **
 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
 ** use the value in register P3 as a key. If cursor P1 refers

@@ -69613,6 +70560,7 @@ case OP_Close: {

 ** See also: Found, NotFound, Distinct, SeekGt, SeekGe, SeekLe
 */
 /* Opcode: SeekLe P1 P2 P3 P4 *
 ** Synopsis: key=r[P3@P4]
 **
 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
 ** use the value in register P3 as a key. If cursor P1 refers

@@ -69625,161 +70573,148 @@ case OP_Close: {

 **
 ** See also: Found, NotFound, Distinct, SeekGt, SeekGe, SeekLt
 */
 case OP_SeekLt:         /* jump, in3 */
 case OP_SeekLe:         /* jump, in3 */
 case OP_SeekGe:         /* jump, in3 */
 case OP_SeekGt: {       /* jump, in3 */
 #if 0  /* local variables moved into u.bc */
 case OP_SeekLT:         /* jump, in3 */
 case OP_SeekLE:         /* jump, in3 */
 case OP_SeekGE:         /* jump, in3 */
 case OP_SeekGT: {       /* jump, in3 */
   int res;
   int oc;
   VdbeCursor *pC;
   UnpackedRecord r;
   int nField;
   i64 iKey;      /* The rowid we are to seek to */
 #endif /* local variables moved into u.bc */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   assert( pOp->p2!=0 );
   u.bc.pC = p->apCsr[pOp->p1];
   assert( u.bc.pC!=0 );
   assert( u.bc.pC->pseudoTableReg==0 );
   assert( OP_SeekLe == OP_SeekLt+1 );
   assert( OP_SeekGe == OP_SeekLt+2 );
   assert( OP_SeekGt == OP_SeekLt+3 );
   assert( u.bc.pC->isOrdered );
   if( ALWAYS(u.bc.pC->pCursor!=0) ){
     u.bc.oc = pOp->opcode;
     u.bc.pC->nullRow = 0;
     if( u.bc.pC->isTable ){
       /* The input value in P3 might be of any type: integer, real, string,
       ** blob, or NULL.  But it needs to be an integer before we can do
       ** the seek, so covert it. */
       pIn3 = &aMem[pOp->p3];
       applyNumericAffinity(pIn3);
       u.bc.iKey = sqlite3VdbeIntValue(pIn3);
       u.bc.pC->rowidIsValid = 0;
       /* If the P3 value could not be converted into an integer without
       ** loss of information, then special processing is required... */
       if( (pIn3->flags & MEM_Int)==0 ){
         if( (pIn3->flags & MEM_Real)==0 ){
           /* If the P3 value cannot be converted into any kind of a number,
           ** then the seek is not possible, so jump to P2 */
           pc = pOp->p2 - 1;
           break;
         }
         /* If we reach this point, then the P3 value must be a floating
         ** point number. */
         assert( (pIn3->flags & MEM_Real)!=0 );
         if( u.bc.iKey==SMALLEST_INT64 && (pIn3->r<(double)u.bc.iKey || pIn3->r>0) ){
           /* The P3 value is too large in magnitude to be expressed as an
           ** integer. */
           u.bc.res = 1;
           if( pIn3->r<0 ){
             if( u.bc.oc>=OP_SeekGe ){  assert( u.bc.oc==OP_SeekGe || u.bc.oc==OP_SeekGt );
               rc = sqlite3BtreeFirst(u.bc.pC->pCursor, &u.bc.res);
               if( rc!=SQLITE_OK ) goto abort_due_to_error;
             }
           }else{
             if( u.bc.oc<=OP_SeekLe ){  assert( u.bc.oc==OP_SeekLt || u.bc.oc==OP_SeekLe );
               rc = sqlite3BtreeLast(u.bc.pC->pCursor, &u.bc.res);
               if( rc!=SQLITE_OK ) goto abort_due_to_error;
             }
           }
           if( u.bc.res ){
             pc = pOp->p2 - 1;
           }
           break;
         }else if( u.bc.oc==OP_SeekLt || u.bc.oc==OP_SeekGe ){
           /* Use the ceiling() function to convert real->int */
           if( pIn3->r > (double)u.bc.iKey ) u.bc.iKey++;
         }else{
           /* Use the floor() function to convert real->int */
           assert( u.bc.oc==OP_SeekLe || u.bc.oc==OP_SeekGt );
           if( pIn3->r < (double)u.bc.iKey ) u.bc.iKey--;
         }
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( pC->pseudoTableReg==0 );
   assert( OP_SeekLE == OP_SeekLT+1 );
   assert( OP_SeekGE == OP_SeekLT+2 );
   assert( OP_SeekGT == OP_SeekLT+3 );
   assert( pC->isOrdered );
   assert( pC->pCursor!=0 );
   oc = pOp->opcode;
   pC->nullRow = 0;
   if( pC->isTable ){
     /* The input value in P3 might be of any type: integer, real, string,
     ** blob, or NULL.  But it needs to be an integer before we can do
     ** the seek, so covert it. */
     pIn3 = &aMem[pOp->p3];
     applyNumericAffinity(pIn3);
     iKey = sqlite3VdbeIntValue(pIn3);
     pC->rowidIsValid = 0;
     /* If the P3 value could not be converted into an integer without
     ** loss of information, then special processing is required... */
     if( (pIn3->flags & MEM_Int)==0 ){
       if( (pIn3->flags & MEM_Real)==0 ){
         /* If the P3 value cannot be converted into any kind of a number,
         ** then the seek is not possible, so jump to P2 */
         pc = pOp->p2 - 1;  VdbeBranchTaken(1,2);
         break;
       }
       rc = sqlite3BtreeMovetoUnpacked(u.bc.pC->pCursor, 0, (u64)u.bc.iKey, 0, &u.bc.res);
       if( rc!=SQLITE_OK ){
         goto abort_due_to_error;
       /* If the approximation iKey is larger than the actual real search
       ** term, substitute >= for > and < for <=. e.g. if the search term
       ** is 4.9 and the integer approximation 5:
       **
       **        (x >  4.9)    ->     (x >= 5)
       **        (x <= 4.9)    ->     (x <  5)
       */
       if( pIn3->r<(double)iKey ){
         assert( OP_SeekGE==(OP_SeekGT-1) );
         assert( OP_SeekLT==(OP_SeekLE-1) );
         assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) );
         if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--;
       }
       if( u.bc.res==0 ){
         u.bc.pC->rowidIsValid = 1;
         u.bc.pC->lastRowid = u.bc.iKey;
       /* If the approximation iKey is smaller than the actual real search
       ** term, substitute <= for < and > for >=.  */
       else if( pIn3->r>(double)iKey ){
         assert( OP_SeekLE==(OP_SeekLT+1) );
         assert( OP_SeekGT==(OP_SeekGE+1) );
         assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) );
         if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++;
       }
     }else{
       u.bc.nField = pOp->p4.i;
       assert( pOp->p4type==P4_INT32 );
       assert( u.bc.nField>0 );
       u.bc.r.pKeyInfo = u.bc.pC->pKeyInfo;
       u.bc.r.nField = (u16)u.bc.nField;
       /* The next line of code computes as follows, only faster:
       **   if( u.bc.oc==OP_SeekGt || u.bc.oc==OP_SeekLe ){
       **     u.bc.r.flags = UNPACKED_INCRKEY;
       **   }else{
       **     u.bc.r.flags = 0;
       **   }
       */
       u.bc.r.flags = (u8)(UNPACKED_INCRKEY * (1 & (u.bc.oc - OP_SeekLt)));
       assert( u.bc.oc!=OP_SeekGt || u.bc.r.flags==UNPACKED_INCRKEY );
       assert( u.bc.oc!=OP_SeekLe || u.bc.r.flags==UNPACKED_INCRKEY );
       assert( u.bc.oc!=OP_SeekGe || u.bc.r.flags==0 );
       assert( u.bc.oc!=OP_SeekLt || u.bc.r.flags==0 );
     }
     rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)iKey, 0, &res);
     if( rc!=SQLITE_OK ){
       goto abort_due_to_error;
     }
     if( res==0 ){
       pC->rowidIsValid = 1;
       pC->lastRowid = iKey;
     }
   }else{
     nField = pOp->p4.i;
     assert( pOp->p4type==P4_INT32 );
     assert( nField>0 );
     r.pKeyInfo = pC->pKeyInfo;
     r.nField = (u16)nField;
     /* The next line of code computes as follows, only faster:
     **   if( oc==OP_SeekGT || oc==OP_SeekLE ){
     **     r.default_rc = -1;
     **   }else{
     **     r.default_rc = +1;
     **   }
     */
     r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1);
     assert( oc!=OP_SeekGT || r.default_rc==-1 );
     assert( oc!=OP_SeekLE || r.default_rc==-1 );
     assert( oc!=OP_SeekGE || r.default_rc==+1 );
     assert( oc!=OP_SeekLT || r.default_rc==+1 );
       u.bc.r.aMem = &aMem[pOp->p3];
     r.aMem = &aMem[pOp->p3];
 #ifdef SQLITE_DEBUG
       { int i; for(i=0; i<u.bc.r.nField; i++) assert( memIsValid(&u.bc.r.aMem[i]) ); }
     { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
 #endif
       ExpandBlob(u.bc.r.aMem);
       rc = sqlite3BtreeMovetoUnpacked(u.bc.pC->pCursor, &u.bc.r, 0, 0, &u.bc.res);
       if( rc!=SQLITE_OK ){
         goto abort_due_to_error;
       }
       u.bc.pC->rowidIsValid = 0;
     ExpandBlob(r.aMem);
     rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, &r, 0, 0, &res);
     if( rc!=SQLITE_OK ){
       goto abort_due_to_error;
     }
     u.bc.pC->deferredMoveto = 0;
     u.bc.pC->cacheStatus = CACHE_STALE;
     pC->rowidIsValid = 0;
   }
   pC->deferredMoveto = 0;
   pC->cacheStatus = CACHE_STALE;
 #ifdef SQLITE_TEST
     sqlite3_search_count++;
   sqlite3_search_count++;
 #endif
     if( u.bc.oc>=OP_SeekGe ){  assert( u.bc.oc==OP_SeekGe || u.bc.oc==OP_SeekGt );
       if( u.bc.res<0 || (u.bc.res==0 && u.bc.oc==OP_SeekGt) ){
         rc = sqlite3BtreeNext(u.bc.pC->pCursor, &u.bc.res);
         if( rc!=SQLITE_OK ) goto abort_due_to_error;
         u.bc.pC->rowidIsValid = 0;
       }else{
         u.bc.res = 0;
       }
   if( oc>=OP_SeekGE ){  assert( oc==OP_SeekGE || oc==OP_SeekGT );
     if( res<0 || (res==0 && oc==OP_SeekGT) ){
       res = 0;
       rc = sqlite3BtreeNext(pC->pCursor, &res);
       if( rc!=SQLITE_OK ) goto abort_due_to_error;
       pC->rowidIsValid = 0;
     }else{
       assert( u.bc.oc==OP_SeekLt || u.bc.oc==OP_SeekLe );
       if( u.bc.res>0 || (u.bc.res==0 && u.bc.oc==OP_SeekLt) ){
         rc = sqlite3BtreePrevious(u.bc.pC->pCursor, &u.bc.res);
         if( rc!=SQLITE_OK ) goto abort_due_to_error;
         u.bc.pC->rowidIsValid = 0;
       }else{
         /* u.bc.res might be negative because the table is empty.  Check to
         ** see if this is the case.
         */
         u.bc.res = sqlite3BtreeEof(u.bc.pC->pCursor);
       }
     }
     assert( pOp->p2>0 );
     if( u.bc.res ){
       pc = pOp->p2 - 1;
       res = 0;
     }
   }else{
     /* This happens when attempting to open the sqlite3_master table
     ** for read access returns SQLITE_EMPTY. In this case always
     ** take the jump (since there are no records in the table).
     */
     assert( oc==OP_SeekLT || oc==OP_SeekLE );
     if( res>0 || (res==0 && oc==OP_SeekLT) ){
       res = 0;
       rc = sqlite3BtreePrevious(pC->pCursor, &res);
       if( rc!=SQLITE_OK ) goto abort_due_to_error;
       pC->rowidIsValid = 0;
     }else{
       /* res might be negative because the table is empty.  Check to
       ** see if this is the case.
       */
       res = sqlite3BtreeEof(pC->pCursor);
     }
   }
   assert( pOp->p2>0 );
   VdbeBranchTaken(res!=0,2);
   if( res ){
     pc = pOp->p2 - 1;
   }
   break;
 }
 /* Opcode: Seek P1 P2 * * *
 ** Synopsis:  intkey=r[P2]
 **
 ** P1 is an open table cursor and P2 is a rowid integer.  Arrange
 ** for P1 to move so that it points to the rowid given by P2.

@@ -69789,26 +70724,24 @@ case OP_SeekGt: { /* jump, in3 */

 ** occur, no unnecessary I/O happens.
 */
 case OP_Seek: {    /* in2 */
 #if 0  /* local variables moved into u.bd */
   VdbeCursor *pC;
 #endif /* local variables moved into u.bd */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bd.pC = p->apCsr[pOp->p1];
   assert( u.bd.pC!=0 );
   if( ALWAYS(u.bd.pC->pCursor!=0) ){
     assert( u.bd.pC->isTable );
     u.bd.pC->nullRow = 0;
     pIn2 = &aMem[pOp->p2];
     u.bd.pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
     u.bd.pC->rowidIsValid = 0;
     u.bd.pC->deferredMoveto = 1;
   }
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( pC->pCursor!=0 );
   assert( pC->isTable );
   pC->nullRow = 0;
   pIn2 = &aMem[pOp->p2];
   pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
   pC->rowidIsValid = 0;
   pC->deferredMoveto = 1;
   break;
 }
 /* Opcode: Found P1 P2 P3 P4 *
 ** Synopsis: key=r[P3@P4]
 **
 ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
 ** P4>0 then register P3 is the first of P4 registers that form an unpacked

@@ -69817,8 +70750,11 @@ case OP_Seek: { /* in2 */

 ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
 ** is a prefix of any entry in P1 then a jump is made to P2 and
 ** P1 is left pointing at the matching entry.
 **
 ** See also: NotFound, NoConflict, NotExists. SeekGe
 */
 /* Opcode: NotFound P1 P2 P3 P4 *
 ** Synopsis: key=r[P3@P4]
 **
 ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
 ** P4>0 then register P3 is the first of P4 registers that form an unpacked

@@ -69830,216 +70766,154 @@ case OP_Seek: { /* in2 */

 ** falls through to the next instruction and P1 is left pointing at the
 ** matching entry.
 **
 ** See also: Found, NotExists, IsUnique
 ** See also: Found, NotExists, NoConflict
 */
 /* Opcode: NoConflict P1 P2 P3 P4 *
 ** Synopsis: key=r[P3@P4]
 **
 ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
 ** P4>0 then register P3 is the first of P4 registers that form an unpacked
 ** record.
 **
 ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
 ** contains any NULL value, jump immediately to P2.  If all terms of the
 ** record are not-NULL then a check is done to determine if any row in the
 ** P1 index btree has a matching key prefix.  If there are no matches, jump
 ** immediately to P2.  If there is a match, fall through and leave the P1
 ** cursor pointing to the matching row.
 **
 ** This opcode is similar to OP_NotFound with the exceptions that the
 ** branch is always taken if any part of the search key input is NULL.
 **
 ** See also: NotFound, Found, NotExists
 */
 case OP_NoConflict:     /* jump, in3 */
 case OP_NotFound:       /* jump, in3 */
 case OP_Found: {        /* jump, in3 */
 #if 0  /* local variables moved into u.be */
   int alreadyExists;
   int ii;
   VdbeCursor *pC;
   int res;
   char *pFree;
   UnpackedRecord *pIdxKey;
   UnpackedRecord r;
   char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
 #endif /* local variables moved into u.be */
   char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*4 + 7];
 #ifdef SQLITE_TEST
   sqlite3_found_count++;
   if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++;
 #endif
   u.be.alreadyExists = 0;
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   assert( pOp->p4type==P4_INT32 );
   u.be.pC = p->apCsr[pOp->p1];
   assert( u.be.pC!=0 );
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   pIn3 = &aMem[pOp->p3];
   if( ALWAYS(u.be.pC->pCursor!=0) ){
     assert( u.be.pC->isTable==0 );
     if( pOp->p4.i>0 ){
       u.be.r.pKeyInfo = u.be.pC->pKeyInfo;
       u.be.r.nField = (u16)pOp->p4.i;
       u.be.r.aMem = pIn3;
   assert( pC->pCursor!=0 );
   assert( pC->isTable==0 );
   pFree = 0;  /* Not needed.  Only used to suppress a compiler warning. */
   if( pOp->p4.i>0 ){
     r.pKeyInfo = pC->pKeyInfo;
     r.nField = (u16)pOp->p4.i;
     r.aMem = pIn3;
     for(ii=0; ii<r.nField; ii++){
       assert( memIsValid(&r.aMem[ii]) );
       ExpandBlob(&r.aMem[ii]);
 #ifdef SQLITE_DEBUG
       { int i; for(i=0; i<u.be.r.nField; i++) assert( memIsValid(&u.be.r.aMem[i]) ); }
       if( ii ) REGISTER_TRACE(pOp->p3+ii, &r.aMem[ii]);
 #endif
       u.be.r.flags = UNPACKED_PREFIX_MATCH;
       u.be.pIdxKey = &u.be.r;
     }else{
       u.be.pIdxKey = sqlite3VdbeAllocUnpackedRecord(
           u.be.pC->pKeyInfo, u.be.aTempRec, sizeof(u.be.aTempRec), &u.be.pFree
       );
       if( u.be.pIdxKey==0 ) goto no_mem;
       assert( pIn3->flags & MEM_Blob );
       assert( (pIn3->flags & MEM_Zero)==0 );  /* zeroblobs already expanded */
       sqlite3VdbeRecordUnpack(u.be.pC->pKeyInfo, pIn3->n, pIn3->z, u.be.pIdxKey);
       u.be.pIdxKey->flags |= UNPACKED_PREFIX_MATCH;
     }
     rc = sqlite3BtreeMovetoUnpacked(u.be.pC->pCursor, u.be.pIdxKey, 0, 0, &u.be.res);
     if( pOp->p4.i==0 ){
       sqlite3DbFree(db, u.be.pFree);
     }
     if( rc!=SQLITE_OK ){
       break;
     pIdxKey = &r;
   }else{
     pIdxKey = sqlite3VdbeAllocUnpackedRecord(
         pC->pKeyInfo, aTempRec, sizeof(aTempRec), &pFree
     );
     if( pIdxKey==0 ) goto no_mem;
     assert( pIn3->flags & MEM_Blob );
     assert( (pIn3->flags & MEM_Zero)==0 );  /* zeroblobs already expanded */
     sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
   }
   pIdxKey->default_rc = 0;
   if( pOp->opcode==OP_NoConflict ){
     /* For the OP_NoConflict opcode, take the jump if any of the
     ** input fields are NULL, since any key with a NULL will not
     ** conflict */
     for(ii=0; ii<r.nField; ii++){
       if( r.aMem[ii].flags & MEM_Null ){
         pc = pOp->p2 - 1; VdbeBranchTaken(1,2);
         break;
       }
     }
     u.be.alreadyExists = (u.be.res==0);
     u.be.pC->deferredMoveto = 0;
     u.be.pC->cacheStatus = CACHE_STALE;
   }
   if( pOp->opcode==OP_Found ){
     if( u.be.alreadyExists ) pc = pOp->p2 - 1;
   }else{
     if( !u.be.alreadyExists ) pc = pOp->p2 - 1;
   rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, pIdxKey, 0, 0, &res);
   if( pOp->p4.i==0 ){
     sqlite3DbFree(db, pFree);
   }
   break;
 }
 /* Opcode: IsUnique P1 P2 P3 P4 *
 **
 ** Cursor P1 is open on an index b-tree - that is to say, a btree which
 ** no data and where the key are records generated by OP_MakeRecord with
 ** the list field being the integer ROWID of the entry that the index
 ** entry refers to.
 **
 ** The P3 register contains an integer record number. Call this record
 ** number R. Register P4 is the first in a set of N contiguous registers
 ** that make up an unpacked index key that can be used with cursor P1.
 ** The value of N can be inferred from the cursor. N includes the rowid
 ** value appended to the end of the index record. This rowid value may
 ** or may not be the same as R.
 **
 ** If any of the N registers beginning with register P4 contains a NULL
 ** value, jump immediately to P2.
 **
 ** Otherwise, this instruction checks if cursor P1 contains an entry
 ** where the first (N-1) fields match but the rowid value at the end
 ** of the index entry is not R. If there is no such entry, control jumps
 ** to instruction P2. Otherwise, the rowid of the conflicting index
 ** entry is copied to register P3 and control falls through to the next
 ** instruction.
 **
 ** See also: NotFound, NotExists, Found
 */
 case OP_IsUnique: {        /* jump, in3 */
 #if 0  /* local variables moved into u.bf */
   u16 ii;
   VdbeCursor *pCx;
   BtCursor *pCrsr;
   u16 nField;
   Mem *aMx;
   UnpackedRecord r;                  /* B-Tree index search key */
   i64 R;                             /* Rowid stored in register P3 */
 #endif /* local variables moved into u.bf */
   pIn3 = &aMem[pOp->p3];
   u.bf.aMx = &aMem[pOp->p4.i];
   /* Assert that the values of parameters P1 and P4 are in range. */
   assert( pOp->p4type==P4_INT32 );
   assert( pOp->p4.i>0 && pOp->p4.i<=(p->nMem-p->nCursor) );
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   /* Find the index cursor. */
   u.bf.pCx = p->apCsr[pOp->p1];
   assert( u.bf.pCx->deferredMoveto==0 );
   u.bf.pCx->seekResult = 0;
   u.bf.pCx->cacheStatus = CACHE_STALE;
   u.bf.pCrsr = u.bf.pCx->pCursor;
   /* If any of the values are NULL, take the jump. */
   u.bf.nField = u.bf.pCx->pKeyInfo->nField;
   for(u.bf.ii=0; u.bf.ii<u.bf.nField; u.bf.ii++){
     if( u.bf.aMx[u.bf.ii].flags & MEM_Null ){
       pc = pOp->p2 - 1;
       u.bf.pCrsr = 0;
       break;
     }
   if( rc!=SQLITE_OK ){
     break;
   }
   assert( (u.bf.aMx[u.bf.nField].flags & MEM_Null)==0 );
   if( u.bf.pCrsr!=0 ){
     /* Populate the index search key. */
     u.bf.r.pKeyInfo = u.bf.pCx->pKeyInfo;
     u.bf.r.nField = u.bf.nField + 1;
     u.bf.r.flags = UNPACKED_PREFIX_SEARCH;
     u.bf.r.aMem = u.bf.aMx;
 #ifdef SQLITE_DEBUG
     { int i; for(i=0; i<u.bf.r.nField; i++) assert( memIsValid(&u.bf.r.aMem[i]) ); }
 #endif
     /* Extract the value of u.bf.R from register P3. */
     sqlite3VdbeMemIntegerify(pIn3);
     u.bf.R = pIn3->u.i;
     /* Search the B-Tree index. If no conflicting record is found, jump
     ** to P2. Otherwise, copy the rowid of the conflicting record to
     ** register P3 and fall through to the next instruction.  */
     rc = sqlite3BtreeMovetoUnpacked(u.bf.pCrsr, &u.bf.r, 0, 0, &u.bf.pCx->seekResult);
     if( (u.bf.r.flags & UNPACKED_PREFIX_SEARCH) || u.bf.r.rowid==u.bf.R ){
       pc = pOp->p2 - 1;
     }else{
       pIn3->u.i = u.bf.r.rowid;
     }
   pC->seekResult = res;
   alreadyExists = (res==0);
   pC->nullRow = 1-alreadyExists;
   pC->deferredMoveto = 0;
   pC->cacheStatus = CACHE_STALE;
   if( pOp->opcode==OP_Found ){
     VdbeBranchTaken(alreadyExists!=0,2);
     if( alreadyExists ) pc = pOp->p2 - 1;
   }else{
     VdbeBranchTaken(alreadyExists==0,2);
     if( !alreadyExists ) pc = pOp->p2 - 1;
   }
   break;
 }
 /* Opcode: NotExists P1 P2 P3 * *
 ** Synopsis: intkey=r[P3]
 **
 ** Use the content of register P3 as an integer key.  If a record
 ** with that key does not exist in table of P1, then jump to P2.
 ** If the record does exist, then fall through.  The cursor is left
 ** pointing to the record if it exists.
 ** P1 is the index of a cursor open on an SQL table btree (with integer
 ** keys).  P3 is an integer rowid.  If P1 does not contain a record with
 ** rowid P3 then jump immediately to P2.  If P1 does contain a record
 ** with rowid P3 then leave the cursor pointing at that record and fall
 ** through to the next instruction.
 **
 ** The difference between this operation and NotFound is that this
 ** operation assumes the key is an integer and that P1 is a table whereas
 ** NotFound assumes key is a blob constructed from MakeRecord and
 ** P1 is an index.
 ** The OP_NotFound opcode performs the same operation on index btrees
 ** (with arbitrary multi-value keys).
 **
 ** See also: Found, NotFound, IsUnique
 ** See also: Found, NotFound, NoConflict
 */
 case OP_NotExists: {        /* jump, in3 */
 #if 0  /* local variables moved into u.bg */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   int res;
   u64 iKey;
 #endif /* local variables moved into u.bg */
   pIn3 = &aMem[pOp->p3];
   assert( pIn3->flags & MEM_Int );
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bg.pC = p->apCsr[pOp->p1];
   assert( u.bg.pC!=0 );
   assert( u.bg.pC->isTable );
   assert( u.bg.pC->pseudoTableReg==0 );
   u.bg.pCrsr = u.bg.pC->pCursor;
   if( ALWAYS(u.bg.pCrsr!=0) ){
     u.bg.res = 0;
     u.bg.iKey = pIn3->u.i;
     rc = sqlite3BtreeMovetoUnpacked(u.bg.pCrsr, 0, u.bg.iKey, 0, &u.bg.res);
     u.bg.pC->lastRowid = pIn3->u.i;
     u.bg.pC->rowidIsValid = u.bg.res==0 ?1:0;
     u.bg.pC->nullRow = 0;
     u.bg.pC->cacheStatus = CACHE_STALE;
     u.bg.pC->deferredMoveto = 0;
     if( u.bg.res!=0 ){
       pc = pOp->p2 - 1;
       assert( u.bg.pC->rowidIsValid==0 );
     }
     u.bg.pC->seekResult = u.bg.res;
   }else{
     /* This happens when an attempt to open a read cursor on the
     ** sqlite_master table returns SQLITE_EMPTY.
     */
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( pC->isTable );
   assert( pC->pseudoTableReg==0 );
   pCrsr = pC->pCursor;
   assert( pCrsr!=0 );
   res = 0;
   iKey = pIn3->u.i;
   rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res);
   pC->lastRowid = pIn3->u.i;
   pC->rowidIsValid = res==0 ?1:0;
   pC->nullRow = 0;
   pC->cacheStatus = CACHE_STALE;
   pC->deferredMoveto = 0;
   VdbeBranchTaken(res!=0,2);
   if( res!=0 ){
     pc = pOp->p2 - 1;
     assert( u.bg.pC->rowidIsValid==0 );
     u.bg.pC->seekResult = 0;
     assert( pC->rowidIsValid==0 );
   }
   pC->seekResult = res;
   break;
 }
 /* Opcode: Sequence P1 P2 * * *
 ** Synopsis: r[P2]=rowid
 **
 ** Find the next available sequence number for cursor P1.
 ** Write the sequence number into register P2.

@@ -70055,6 +70929,7 @@ case OP_Sequence: { /* out2-prerelease */

 /* Opcode: NewRowid P1 P2 P3 * *
 ** Synopsis: r[P2]=rowid
 **
 ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
 ** The record number is not previously used as a key in the database

@@ -70069,21 +70944,19 @@ case OP_Sequence: { /* out2-prerelease */

 ** AUTOINCREMENT feature.
 */
 case OP_NewRowid: {           /* out2-prerelease */
 #if 0  /* local variables moved into u.bh */
   i64 v;                 /* The new rowid */
   VdbeCursor *pC;        /* Cursor of table to get the new rowid */
   int res;               /* Result of an sqlite3BtreeLast() */
   int cnt;               /* Counter to limit the number of searches */
   Mem *pMem;             /* Register holding largest rowid for AUTOINCREMENT */
   VdbeFrame *pFrame;     /* Root frame of VDBE */
 #endif /* local variables moved into u.bh */
   u.bh.v = 0;
   u.bh.res = 0;
   v = 0;
   res = 0;
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bh.pC = p->apCsr[pOp->p1];
   assert( u.bh.pC!=0 );
   if( NEVER(u.bh.pC->pCursor==0) ){
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   if( NEVER(pC->pCursor==0) ){
     /* The zero initialization above is all that is needed */
   }else{
     /* The next rowid or record number (different terms for the same

@@ -70099,7 +70972,7 @@ case OP_NewRowid: { /* out2-prerelease */

     ** succeeded.  If the random rowid does exist, we select a new one
     ** and try again, up to 100 times.
     */
     assert( u.bh.pC->isTable );
     assert( pC->isTable );
 #ifdef SQLITE_32BIT_ROWID
 #   define MAX_ROWID 0x7fffffff

@@ -70111,61 +70984,56 @@ case OP_NewRowid: { /* out2-prerelease */

 #   define MAX_ROWID  (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
 #endif
     if( !u.bh.pC->useRandomRowid ){
       u.bh.v = sqlite3BtreeGetCachedRowid(u.bh.pC->pCursor);
       if( u.bh.v==0 ){
         rc = sqlite3BtreeLast(u.bh.pC->pCursor, &u.bh.res);
         if( rc!=SQLITE_OK ){
           goto abort_due_to_error;
         }
         if( u.bh.res ){
           u.bh.v = 1;   /* IMP: R-61914-48074 */
     if( !pC->useRandomRowid ){
       rc = sqlite3BtreeLast(pC->pCursor, &res);
       if( rc!=SQLITE_OK ){
         goto abort_due_to_error;
       }
       if( res ){
         v = 1;   /* IMP: R-61914-48074 */
       }else{
         assert( sqlite3BtreeCursorIsValid(pC->pCursor) );
         rc = sqlite3BtreeKeySize(pC->pCursor, &v);
         assert( rc==SQLITE_OK );   /* Cannot fail following BtreeLast() */
         if( v>=MAX_ROWID ){
           pC->useRandomRowid = 1;
         }else{
           assert( sqlite3BtreeCursorIsValid(u.bh.pC->pCursor) );
           rc = sqlite3BtreeKeySize(u.bh.pC->pCursor, &u.bh.v);
           assert( rc==SQLITE_OK );   /* Cannot fail following BtreeLast() */
           if( u.bh.v>=MAX_ROWID ){
             u.bh.pC->useRandomRowid = 1;
           }else{
             u.bh.v++;   /* IMP: R-29538-34987 */
           }
           v++;   /* IMP: R-29538-34987 */
         }
       }
     }
 #ifndef SQLITE_OMIT_AUTOINCREMENT
       if( pOp->p3 ){
     if( pOp->p3 ){
       /* Assert that P3 is a valid memory cell. */
       assert( pOp->p3>0 );
       if( p->pFrame ){
         for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
         /* Assert that P3 is a valid memory cell. */
         assert( pOp->p3>0 );
         if( p->pFrame ){
           for(u.bh.pFrame=p->pFrame; u.bh.pFrame->pParent; u.bh.pFrame=u.bh.pFrame->pParent);
           /* Assert that P3 is a valid memory cell. */
           assert( pOp->p3<=u.bh.pFrame->nMem );
           u.bh.pMem = &u.bh.pFrame->aMem[pOp->p3];
         }else{
           /* Assert that P3 is a valid memory cell. */
           assert( pOp->p3<=(p->nMem-p->nCursor) );
           u.bh.pMem = &aMem[pOp->p3];
           memAboutToChange(p, u.bh.pMem);
         }
         assert( memIsValid(u.bh.pMem) );
         REGISTER_TRACE(pOp->p3, u.bh.pMem);
         sqlite3VdbeMemIntegerify(u.bh.pMem);
         assert( (u.bh.pMem->flags & MEM_Int)!=0 );  /* mem(P3) holds an integer */
         if( u.bh.pMem->u.i==MAX_ROWID || u.bh.pC->useRandomRowid ){
           rc = SQLITE_FULL;   /* IMP: R-12275-61338 */
           goto abort_due_to_error;
         }
         if( u.bh.v<u.bh.pMem->u.i+1 ){
           u.bh.v = u.bh.pMem->u.i + 1;
         }
         u.bh.pMem->u.i = u.bh.v;
         assert( pOp->p3<=pFrame->nMem );
         pMem = &pFrame->aMem[pOp->p3];
       }else{
         /* Assert that P3 is a valid memory cell. */
         assert( pOp->p3<=(p->nMem-p->nCursor) );
         pMem = &aMem[pOp->p3];
         memAboutToChange(p, pMem);
       }
 #endif
       assert( memIsValid(pMem) );
       sqlite3BtreeSetCachedRowid(u.bh.pC->pCursor, u.bh.v<MAX_ROWID ? u.bh.v+1 : 0);
       REGISTER_TRACE(pOp->p3, pMem);
       sqlite3VdbeMemIntegerify(pMem);
       assert( (pMem->flags & MEM_Int)!=0 );  /* mem(P3) holds an integer */
       if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
         rc = SQLITE_FULL;   /* IMP: R-12275-61338 */
         goto abort_due_to_error;
       }
       if( v<pMem->u.i+1 ){
         v = pMem->u.i + 1;
       }
       pMem->u.i = v;
     }
     if( u.bh.pC->useRandomRowid ){
 #endif
     if( pC->useRandomRowid ){
       /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
       ** largest possible integer (9223372036854775807) then the database
       ** engine starts picking positive candidate ROWIDs at random until

@@ -70173,39 +71041,40 @@ case OP_NewRowid: { /* out2-prerelease */

       assert( pOp->p3==0 );  /* We cannot be in random rowid mode if this is
                              ** an AUTOINCREMENT table. */
       /* on the first attempt, simply do one more than previous */
       u.bh.v = lastRowid;
       u.bh.v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
       u.bh.v++; /* ensure non-zero */
       u.bh.cnt = 0;
       while(   ((rc = sqlite3BtreeMovetoUnpacked(u.bh.pC->pCursor, 0, (u64)u.bh.v,
 , &u.bh.res))==SQLITE_OK)
             && (u.bh.res==0)
             && (++u.bh.cnt<100)){
       v = lastRowid;
       v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
       v++; /* ensure non-zero */
       cnt = 0;
       while(   ((rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)v,
 , &res))==SQLITE_OK)
             && (res==0)
             && (++cnt<100)){
         /* collision - try another random rowid */
         sqlite3_randomness(sizeof(u.bh.v), &u.bh.v);
         if( u.bh.cnt<5 ){
         sqlite3_randomness(sizeof(v), &v);
         if( cnt<5 ){
           /* try "small" random rowids for the initial attempts */
           u.bh.v &= 0xffffff;
           v &= 0xffffff;
         }else{
           u.bh.v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
           v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
         }
         u.bh.v++; /* ensure non-zero */
         v++; /* ensure non-zero */
       }
       if( rc==SQLITE_OK && u.bh.res==0 ){
       if( rc==SQLITE_OK && res==0 ){
         rc = SQLITE_FULL;   /* IMP: R-38219-53002 */
         goto abort_due_to_error;
       }
       assert( u.bh.v>0 );  /* EV: R-40812-03570 */
       assert( v>0 );  /* EV: R-40812-03570 */
     }
     u.bh.pC->rowidIsValid = 0;
     u.bh.pC->deferredMoveto = 0;
     u.bh.pC->cacheStatus = CACHE_STALE;
     pC->rowidIsValid = 0;
     pC->deferredMoveto = 0;
     pC->cacheStatus = CACHE_STALE;
   }
   pOut->u.i = u.bh.v;
   pOut->u.i = v;
   break;
 }
 /* Opcode: Insert P1 P2 P3 P4 P5
 ** Synopsis: intkey=r[P3] data=r[P2]
 **
 ** Write an entry into the table of cursor P1.  A new entry is
 ** created if it doesn't already exist or the data for an existing

@@ -70245,13 +71114,13 @@ case OP_NewRowid: { /* out2-prerelease */

 ** for indices is OP_IdxInsert.
 */
 /* Opcode: InsertInt P1 P2 P3 P4 P5
 ** Synopsis:  intkey=P3 data=r[P2]
 **
 ** This works exactly like OP_Insert except that the key is the
 ** integer value P3, not the value of the integer stored in register P3.
 */
 case OP_Insert:
 case OP_InsertInt: {
 #if 0  /* local variables moved into u.bi */
   Mem *pData;       /* MEM cell holding data for the record to be inserted */
   Mem *pKey;        /* MEM cell holding key  for the record */
   i64 iKey;         /* The integer ROWID or key for the record to be inserted */

@@ -70261,60 +71130,58 @@ case OP_InsertInt: {

   const char *zDb;  /* database name - used by the update hook */
   const char *zTbl; /* Table name - used by the opdate hook */
   int op;           /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */
 #endif /* local variables moved into u.bi */
   u.bi.pData = &aMem[pOp->p2];
   pData = &aMem[pOp->p2];
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   assert( memIsValid(u.bi.pData) );
   u.bi.pC = p->apCsr[pOp->p1];
   assert( u.bi.pC!=0 );
   assert( u.bi.pC->pCursor!=0 );
   assert( u.bi.pC->pseudoTableReg==0 );
   assert( u.bi.pC->isTable );
   REGISTER_TRACE(pOp->p2, u.bi.pData);
   assert( memIsValid(pData) );
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( pC->pCursor!=0 );
   assert( pC->pseudoTableReg==0 );
   assert( pC->isTable );
   REGISTER_TRACE(pOp->p2, pData);
   if( pOp->opcode==OP_Insert ){
     u.bi.pKey = &aMem[pOp->p3];
     assert( u.bi.pKey->flags & MEM_Int );
     assert( memIsValid(u.bi.pKey) );
     REGISTER_TRACE(pOp->p3, u.bi.pKey);
     u.bi.iKey = u.bi.pKey->u.i;
     pKey = &aMem[pOp->p3];
     assert( pKey->flags & MEM_Int );
     assert( memIsValid(pKey) );
     REGISTER_TRACE(pOp->p3, pKey);
     iKey = pKey->u.i;
   }else{
     assert( pOp->opcode==OP_InsertInt );
     u.bi.iKey = pOp->p3;
     iKey = pOp->p3;
   }
   if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
   if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = lastRowid = u.bi.iKey;
   if( u.bi.pData->flags & MEM_Null ){
     u.bi.pData->z = 0;
     u.bi.pData->n = 0;
   if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = lastRowid = iKey;
   if( pData->flags & MEM_Null ){
     pData->z = 0;
     pData->n = 0;
   }else{
     assert( u.bi.pData->flags & (MEM_Blob|MEM_Str) );
     assert( pData->flags & (MEM_Blob|MEM_Str) );
   }
   u.bi.seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bi.pC->seekResult : 0);
   if( u.bi.pData->flags & MEM_Zero ){
     u.bi.nZero = u.bi.pData->u.nZero;
   seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
   if( pData->flags & MEM_Zero ){
     nZero = pData->u.nZero;
   }else{
     u.bi.nZero = 0;
     nZero = 0;
   }
   sqlite3BtreeSetCachedRowid(u.bi.pC->pCursor, 0);
   rc = sqlite3BtreeInsert(u.bi.pC->pCursor, 0, u.bi.iKey,
                           u.bi.pData->z, u.bi.pData->n, u.bi.nZero,
                           pOp->p5 & OPFLAG_APPEND, u.bi.seekResult
   rc = sqlite3BtreeInsert(pC->pCursor, 0, iKey,
                           pData->z, pData->n, nZero,
                           (pOp->p5 & OPFLAG_APPEND)!=0, seekResult
   );
   u.bi.pC->rowidIsValid = 0;
   u.bi.pC->deferredMoveto = 0;
   u.bi.pC->cacheStatus = CACHE_STALE;
   pC->rowidIsValid = 0;
   pC->deferredMoveto = 0;
   pC->cacheStatus = CACHE_STALE;
   /* Invoke the update-hook if required. */
   if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
     u.bi.zDb = db->aDb[u.bi.pC->iDb].zName;
     u.bi.zTbl = pOp->p4.z;
     u.bi.op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT);
     assert( u.bi.pC->isTable );
     db->xUpdateCallback(db->pUpdateArg, u.bi.op, u.bi.zDb, u.bi.zTbl, u.bi.iKey);
     assert( u.bi.pC->iDb>=0 );
     zDb = db->aDb[pC->iDb].zName;
     zTbl = pOp->p4.z;
     op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT);
     assert( pC->isTable );
     db->xUpdateCallback(db->pUpdateArg, op, zDb, zTbl, iKey);
     assert( pC->iDb>=0 );
   }
   break;
 }

@@ -70340,47 +71207,34 @@ case OP_InsertInt: {

 ** using OP_NotFound prior to invoking this opcode.
 */
 case OP_Delete: {
 #if 0  /* local variables moved into u.bj */
   i64 iKey;
   VdbeCursor *pC;
 #endif /* local variables moved into u.bj */
   u.bj.iKey = 0;
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bj.pC = p->apCsr[pOp->p1];
   assert( u.bj.pC!=0 );
   assert( u.bj.pC->pCursor!=0 );  /* Only valid for real tables, no pseudotables */
   /* If the update-hook will be invoked, set u.bj.iKey to the rowid of the
   ** row being deleted.
   */
   if( db->xUpdateCallback && pOp->p4.z ){
     assert( u.bj.pC->isTable );
     assert( u.bj.pC->rowidIsValid );  /* lastRowid set by previous OP_NotFound */
     u.bj.iKey = u.bj.pC->lastRowid;
   }
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( pC->pCursor!=0 );  /* Only valid for real tables, no pseudotables */
   iKey = pC->lastRowid;      /* Only used for the update hook */
   /* The OP_Delete opcode always follows an OP_NotExists or OP_Last or
   ** OP_Column on the same table without any intervening operations that
   ** might move or invalidate the cursor.  Hence cursor u.bj.pC is always pointing
   ** might move or invalidate the cursor.  Hence cursor pC is always pointing
   ** to the row to be deleted and the sqlite3VdbeCursorMoveto() operation
   ** below is always a no-op and cannot fail.  We will run it anyhow, though,
   ** to guard against future changes to the code generator.
   **/
   assert( u.bj.pC->deferredMoveto==0 );
   rc = sqlite3VdbeCursorMoveto(u.bj.pC);
   assert( pC->deferredMoveto==0 );
   rc = sqlite3VdbeCursorMoveto(pC);
   if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
   sqlite3BtreeSetCachedRowid(u.bj.pC->pCursor, 0);
   rc = sqlite3BtreeDelete(u.bj.pC->pCursor);
   u.bj.pC->cacheStatus = CACHE_STALE;
   rc = sqlite3BtreeDelete(pC->pCursor);
   pC->cacheStatus = CACHE_STALE;
   /* Invoke the update-hook if required. */
   if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
     const char *zDb = db->aDb[u.bj.pC->iDb].zName;
     const char *zTbl = pOp->p4.z;
     db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, zTbl, u.bj.iKey);
     assert( u.bj.pC->iDb>=0 );
   if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z && pC->isTable ){
     db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE,
                         db->aDb[pC->iDb].zName, pOp->p4.z, iKey);
     assert( pC->iDb>=0 );
   }
   if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++;
   break;

@@ -70398,46 +71252,56 @@ case OP_ResetCount: {

   break;
 }
 /* Opcode: SorterCompare P1 P2 P3
 /* Opcode: SorterCompare P1 P2 P3 P4
 ** Synopsis:  if key(P1)!=rtrim(r[P3],P4) goto P2
 **
 ** P1 is a sorter cursor. This instruction compares a prefix of the
 ** the record blob in register P3 against a prefix of the entry that
 ** the sorter cursor currently points to.  The final P4 fields of both
 ** the P3 and sorter record are ignored.
 **
 ** If either P3 or the sorter contains a NULL in one of their significant
 ** fields (not counting the P4 fields at the end which are ignored) then
 ** the comparison is assumed to be equal.
 **
 ** P1 is a sorter cursor. This instruction compares the record blob in
 ** register P3 with the entry that the sorter cursor currently points to.
 ** If, excluding the rowid fields at the end, the two records are a match,
 ** fall through to the next instruction. Otherwise, jump to instruction P2.
 ** Fall through to next instruction if the two records compare equal to
 ** each other.  Jump to P2 if they are different.
 */
 case OP_SorterCompare: {
 #if 0  /* local variables moved into u.bk */
   VdbeCursor *pC;
   int res;
 #endif /* local variables moved into u.bk */
   int nIgnore;
   u.bk.pC = p->apCsr[pOp->p1];
   assert( isSorter(u.bk.pC) );
   pC = p->apCsr[pOp->p1];
   assert( isSorter(pC) );
   assert( pOp->p4type==P4_INT32 );
   pIn3 = &aMem[pOp->p3];
   rc = sqlite3VdbeSorterCompare(u.bk.pC, pIn3, &u.bk.res);
   if( u.bk.res ){
   nIgnore = pOp->p4.i;
   rc = sqlite3VdbeSorterCompare(pC, pIn3, nIgnore, &res);
   VdbeBranchTaken(res!=0,2);
   if( res ){
     pc = pOp->p2-1;
   }
   break;
 };
 /* Opcode: SorterData P1 P2 * * *
 ** Synopsis: r[P2]=data
 **
 ** Write into register P2 the current sorter data for sorter cursor P1.
 */
 case OP_SorterData: {
 #if 0  /* local variables moved into u.bl */
   VdbeCursor *pC;
 #endif /* local variables moved into u.bl */
   pOut = &aMem[pOp->p2];
   u.bl.pC = p->apCsr[pOp->p1];
   assert( u.bl.pC->isSorter );
   rc = sqlite3VdbeSorterRowkey(u.bl.pC, pOut);
   pC = p->apCsr[pOp->p1];
   assert( isSorter(pC) );
   rc = sqlite3VdbeSorterRowkey(pC, pOut);
   break;
 }
 /* Opcode: RowData P1 P2 * * *
 ** Synopsis: r[P2]=data
 **
 ** Write into register P2 the complete row data for cursor P1.
 ** There is no interpretation of the data.

@@ -70448,10 +71312,11 @@ case OP_SorterData: {

 ** of a real table, not a pseudo-table.
 */
 /* Opcode: RowKey P1 P2 * * *
 ** Synopsis: r[P2]=key
 **
 ** Write into register P2 the complete row key for cursor P1.
 ** There is no interpretation of the data.
 ** The key is copied onto the P3 register exactly as
 ** The key is copied onto the P2 register exactly as
 ** it is found in the database file.
 **
 ** If the P1 cursor must be pointing to a valid row (not a NULL row)

@@ -70459,69 +71324,69 @@ case OP_SorterData: {

 */
 case OP_RowKey:
 case OP_RowData: {
 #if 0  /* local variables moved into u.bm */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   u32 n;
   i64 n64;
 #endif /* local variables moved into u.bm */
   pOut = &aMem[pOp->p2];
   memAboutToChange(p, pOut);
   /* Note that RowKey and RowData are really exactly the same instruction */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bm.pC = p->apCsr[pOp->p1];
   assert( u.bm.pC->isSorter==0 );
   assert( u.bm.pC->isTable || pOp->opcode!=OP_RowData );
   assert( u.bm.pC->isIndex || pOp->opcode==OP_RowData );
   assert( u.bm.pC!=0 );
   assert( u.bm.pC->nullRow==0 );
   assert( u.bm.pC->pseudoTableReg==0 );
   assert( u.bm.pC->pCursor!=0 );
   u.bm.pCrsr = u.bm.pC->pCursor;
   assert( sqlite3BtreeCursorIsValid(u.bm.pCrsr) );
   pC = p->apCsr[pOp->p1];
   assert( isSorter(pC)==0 );
   assert( pC->isTable || pOp->opcode!=OP_RowData );
   assert( pC->isTable==0 || pOp->opcode==OP_RowData );
   assert( pC!=0 );
   assert( pC->nullRow==0 );
   assert( pC->pseudoTableReg==0 );
   assert( pC->pCursor!=0 );
   pCrsr = pC->pCursor;
   assert( sqlite3BtreeCursorIsValid(pCrsr) );
   /* The OP_RowKey and OP_RowData opcodes always follow OP_NotExists or
   ** OP_Rewind/Op_Next with no intervening instructions that might invalidate
   ** the cursor.  Hence the following sqlite3VdbeCursorMoveto() call is always
   ** a no-op and can never fail.  But we leave it in place as a safety.
   */
   assert( u.bm.pC->deferredMoveto==0 );
   rc = sqlite3VdbeCursorMoveto(u.bm.pC);
   assert( pC->deferredMoveto==0 );
   rc = sqlite3VdbeCursorMoveto(pC);
   if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
   if( u.bm.pC->isIndex ){
     assert( !u.bm.pC->isTable );
     VVA_ONLY(rc =) sqlite3BtreeKeySize(u.bm.pCrsr, &u.bm.n64);
   if( pC->isTable==0 ){
     assert( !pC->isTable );
     VVA_ONLY(rc =) sqlite3BtreeKeySize(pCrsr, &n64);
     assert( rc==SQLITE_OK );    /* True because of CursorMoveto() call above */
     if( u.bm.n64>db->aLimit[SQLITE_LIMIT_LENGTH] ){
     if( n64>db->aLimit[SQLITE_LIMIT_LENGTH] ){
       goto too_big;
     }
     u.bm.n = (u32)u.bm.n64;
     n = (u32)n64;
   }else{
     VVA_ONLY(rc =) sqlite3BtreeDataSize(u.bm.pCrsr, &u.bm.n);
     VVA_ONLY(rc =) sqlite3BtreeDataSize(pCrsr, &n);
     assert( rc==SQLITE_OK );    /* DataSize() cannot fail */
     if( u.bm.n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
     if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
       goto too_big;
     }
   }
   if( sqlite3VdbeMemGrow(pOut, u.bm.n, 0) ){
   if( sqlite3VdbeMemGrow(pOut, n, 0) ){
     goto no_mem;
   }
   pOut->n = u.bm.n;
   pOut->n = n;
   MemSetTypeFlag(pOut, MEM_Blob);
   if( u.bm.pC->isIndex ){
     rc = sqlite3BtreeKey(u.bm.pCrsr, 0, u.bm.n, pOut->z);
   if( pC->isTable==0 ){
     rc = sqlite3BtreeKey(pCrsr, 0, n, pOut->z);
   }else{
     rc = sqlite3BtreeData(u.bm.pCrsr, 0, u.bm.n, pOut->z);
     rc = sqlite3BtreeData(pCrsr, 0, n, pOut->z);
   }
   pOut->enc = SQLITE_UTF8;  /* In case the blob is ever cast to text */
   UPDATE_MAX_BLOBSIZE(pOut);
   REGISTER_TRACE(pOp->p2, pOut);
   break;
 }
 /* Opcode: Rowid P1 P2 * * *
 ** Synopsis: r[P2]=rowid
 **
 ** Store in register P2 an integer which is the key of the table entry that
 ** P1 is currently point to.

@@ -70531,42 +71396,40 @@ case OP_RowData: {

 ** one opcode now works for both table types.
 */
 case OP_Rowid: {                 /* out2-prerelease */
 #if 0  /* local variables moved into u.bn */
   VdbeCursor *pC;
   i64 v;
   sqlite3_vtab *pVtab;
   const sqlite3_module *pModule;
 #endif /* local variables moved into u.bn */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bn.pC = p->apCsr[pOp->p1];
   assert( u.bn.pC!=0 );
   assert( u.bn.pC->pseudoTableReg==0 || u.bn.pC->nullRow );
   if( u.bn.pC->nullRow ){
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( pC->pseudoTableReg==0 || pC->nullRow );
   if( pC->nullRow ){
     pOut->flags = MEM_Null;
     break;
   }else if( u.bn.pC->deferredMoveto ){
     u.bn.v = u.bn.pC->movetoTarget;
   }else if( pC->deferredMoveto ){
     v = pC->movetoTarget;
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   }else if( u.bn.pC->pVtabCursor ){
     u.bn.pVtab = u.bn.pC->pVtabCursor->pVtab;
     u.bn.pModule = u.bn.pVtab->pModule;
     assert( u.bn.pModule->xRowid );
     rc = u.bn.pModule->xRowid(u.bn.pC->pVtabCursor, &u.bn.v);
     sqlite3VtabImportErrmsg(p, u.bn.pVtab);
   }else if( pC->pVtabCursor ){
     pVtab = pC->pVtabCursor->pVtab;
     pModule = pVtab->pModule;
     assert( pModule->xRowid );
     rc = pModule->xRowid(pC->pVtabCursor, &v);
     sqlite3VtabImportErrmsg(p, pVtab);
 #endif /* SQLITE_OMIT_VIRTUALTABLE */
   }else{
     assert( u.bn.pC->pCursor!=0 );
     rc = sqlite3VdbeCursorMoveto(u.bn.pC);
     assert( pC->pCursor!=0 );
     rc = sqlite3VdbeCursorMoveto(pC);
     if( rc ) goto abort_due_to_error;
     if( u.bn.pC->rowidIsValid ){
       u.bn.v = u.bn.pC->lastRowid;
     if( pC->rowidIsValid ){
       v = pC->lastRowid;
     }else{
       rc = sqlite3BtreeKeySize(u.bn.pC->pCursor, &u.bn.v);
       rc = sqlite3BtreeKeySize(pC->pCursor, &v);
       assert( rc==SQLITE_OK );  /* Always so because of CursorMoveto() above */
     }
   }
   pOut->u.i = u.bn.v;
   pOut->u.i = v;
   break;
 }

@@ -70577,18 +71440,16 @@ case OP_Rowid: { /* out2-prerelease */

 ** write a NULL.
 */
 case OP_NullRow: {
 #if 0  /* local variables moved into u.bo */
   VdbeCursor *pC;
 #endif /* local variables moved into u.bo */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bo.pC = p->apCsr[pOp->p1];
   assert( u.bo.pC!=0 );
   u.bo.pC->nullRow = 1;
   u.bo.pC->rowidIsValid = 0;
   assert( u.bo.pC->pCursor || u.bo.pC->pVtabCursor );
   if( u.bo.pC->pCursor ){
     sqlite3BtreeClearCursor(u.bo.pC->pCursor);
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   pC->nullRow = 1;
   pC->rowidIsValid = 0;
   pC->cacheStatus = CACHE_STALE;
   if( pC->pCursor ){
     sqlite3BtreeClearCursor(pC->pCursor);
   }
   break;
 }

@@ -70602,26 +71463,24 @@ case OP_NullRow: {

 ** to the following instruction.
 */
 case OP_Last: {        /* jump */
 #if 0  /* local variables moved into u.bp */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   int res;
 #endif /* local variables moved into u.bp */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bp.pC = p->apCsr[pOp->p1];
   assert( u.bp.pC!=0 );
   u.bp.pCrsr = u.bp.pC->pCursor;
   u.bp.res = 0;
   if( ALWAYS(u.bp.pCrsr!=0) ){
     rc = sqlite3BtreeLast(u.bp.pCrsr, &u.bp.res);
   }
   u.bp.pC->nullRow = (u8)u.bp.res;
   u.bp.pC->deferredMoveto = 0;
   u.bp.pC->rowidIsValid = 0;
   u.bp.pC->cacheStatus = CACHE_STALE;
   if( pOp->p2>0 && u.bp.res ){
     pc = pOp->p2 - 1;
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   pCrsr = pC->pCursor;
   res = 0;
   assert( pCrsr!=0 );
   rc = sqlite3BtreeLast(pCrsr, &res);
   pC->nullRow = (u8)res;
   pC->deferredMoveto = 0;
   pC->rowidIsValid = 0;
   pC->cacheStatus = CACHE_STALE;
   if( pOp->p2>0 ){
     VdbeBranchTaken(res!=0,2);
     if( res ) pc = pOp->p2 - 1;
   }
   break;
 }

@@ -70657,44 +71516,48 @@ case OP_Sort: { /* jump */

 ** to the following instruction.
 */
 case OP_Rewind: {        /* jump */
 #if 0  /* local variables moved into u.bq */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   int res;
 #endif /* local variables moved into u.bq */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bq.pC = p->apCsr[pOp->p1];
   assert( u.bq.pC!=0 );
   assert( u.bq.pC->isSorter==(pOp->opcode==OP_SorterSort) );
   u.bq.res = 1;
   if( isSorter(u.bq.pC) ){
     rc = sqlite3VdbeSorterRewind(db, u.bq.pC, &u.bq.res);
   }else{
     u.bq.pCrsr = u.bq.pC->pCursor;
     assert( u.bq.pCrsr );
     rc = sqlite3BtreeFirst(u.bq.pCrsr, &u.bq.res);
     u.bq.pC->atFirst = u.bq.res==0 ?1:0;
     u.bq.pC->deferredMoveto = 0;
     u.bq.pC->cacheStatus = CACHE_STALE;
     u.bq.pC->rowidIsValid = 0;
   }
   u.bq.pC->nullRow = (u8)u.bq.res;
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
   res = 1;
   if( isSorter(pC) ){
     rc = sqlite3VdbeSorterRewind(db, pC, &res);
   }else{
     pCrsr = pC->pCursor;
     assert( pCrsr );
     rc = sqlite3BtreeFirst(pCrsr, &res);
     pC->deferredMoveto = 0;
     pC->cacheStatus = CACHE_STALE;
     pC->rowidIsValid = 0;
   }
   pC->nullRow = (u8)res;
   assert( pOp->p2>0 && pOp->p2<p->nOp );
   if( u.bq.res ){
   VdbeBranchTaken(res!=0,2);
   if( res ){
     pc = pOp->p2 - 1;
   }
   break;
 }
 /* Opcode: Next P1 P2 * P4 P5
 /* Opcode: Next P1 P2 P3 P4 P5
 **
 ** Advance cursor P1 so that it points to the next key/data pair in its
 ** table or index.  If there are no more key/value pairs then fall through
 ** to the following instruction.  But if the cursor advance was successful,
 ** jump immediately to P2.
 **
 ** The P1 cursor must be for a real table, not a pseudo-table.
 ** The P1 cursor must be for a real table, not a pseudo-table.  P1 must have
 ** been opened prior to this opcode or the program will segfault.
 **
 ** The P3 value is a hint to the btree implementation. If P3==1, that
 ** means P1 is an SQL index and that this instruction could have been
 ** omitted if that index had been unique.  P3 is usually 0.  P3 is
 ** always either 0 or 1.
 **
 ** P4 is always of type P4_ADVANCE. The function pointer points to
 ** sqlite3BtreeNext().

@@ -70702,16 +71565,27 @@ case OP_Rewind: { /* jump */

 ** If P5 is positive and the jump is taken, then event counter
 ** number P5-1 in the prepared statement is incremented.
 **
 ** See also: Prev
 ** See also: Prev, NextIfOpen
 */
 /* Opcode: NextIfOpen P1 P2 P3 P4 P5
 **
 ** This opcode works just like OP_Next except that if cursor P1 is not
 ** open it behaves a no-op.
 */
 /* Opcode: Prev P1 P2 * * P5
 /* Opcode: Prev P1 P2 P3 P4 P5
 **
 ** Back up cursor P1 so that it points to the previous key/data pair in its
 ** table or index.  If there is no previous key/value pairs then fall through
 ** to the following instruction.  But if the cursor backup was successful,
 ** jump immediately to P2.
 **
 ** The P1 cursor must be for a real table, not a pseudo-table.
 ** The P1 cursor must be for a real table, not a pseudo-table.  If P1 is
 ** not open then the behavior is undefined.
 **
 ** The P3 value is a hint to the btree implementation. If P3==1, that
 ** means P1 is an SQL index and that this instruction could have been
 ** omitted if that index had been unique.  P3 is usually 0.  P3 is
 ** always either 0 or 1.
 **
 ** P4 is always of type P4_ADVANCE. The function pointer points to
 ** sqlite3BtreePrevious().

@@ -70719,46 +71593,58 @@ case OP_Rewind: { /* jump */

 ** If P5 is positive and the jump is taken, then event counter
 ** number P5-1 in the prepared statement is incremented.
 */
 case OP_SorterNext:    /* jump */
 case OP_Prev:          /* jump */
 case OP_Next: {        /* jump */
 #if 0  /* local variables moved into u.br */
 /* Opcode: PrevIfOpen P1 P2 P3 P4 P5
 **
 ** This opcode works just like OP_Prev except that if cursor P1 is not
 ** open it behaves a no-op.
 */
 case OP_SorterNext: {  /* jump */
   VdbeCursor *pC;
   int res;
 #endif /* local variables moved into u.br */
   pC = p->apCsr[pOp->p1];
   assert( isSorter(pC) );
   rc = sqlite3VdbeSorterNext(db, pC, &res);
   goto next_tail;
 case OP_PrevIfOpen:    /* jump */
 case OP_NextIfOpen:    /* jump */
   if( p->apCsr[pOp->p1]==0 ) break;
   /* Fall through */
 case OP_Prev:          /* jump */
 case OP_Next:          /* jump */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   assert( pOp->p5<ArraySize(p->aCounter) );
   u.br.pC = p->apCsr[pOp->p1];
   if( u.br.pC==0 ){
     break;  /* See ticket #2273 */
   }
   assert( u.br.pC->isSorter==(pOp->opcode==OP_SorterNext) );
   if( isSorter(u.br.pC) ){
     assert( pOp->opcode==OP_SorterNext );
     rc = sqlite3VdbeSorterNext(db, u.br.pC, &u.br.res);
   }else{
     /* u.br.res = 1; // Always initialized by the xAdvance() call */
     assert( u.br.pC->deferredMoveto==0 );
     assert( u.br.pC->pCursor );
     assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
     assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
     rc = pOp->p4.xAdvance(u.br.pC->pCursor, &u.br.res);
   }
   u.br.pC->nullRow = (u8)u.br.res;
   u.br.pC->cacheStatus = CACHE_STALE;
   if( u.br.res==0 ){
   pC = p->apCsr[pOp->p1];
   res = pOp->p3;
   assert( pC!=0 );
   assert( pC->deferredMoveto==0 );
   assert( pC->pCursor );
   assert( res==0 || (res==1 && pC->isTable==0) );
   testcase( res==1 );
   assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
   assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
   assert( pOp->opcode!=OP_NextIfOpen || pOp->p4.xAdvance==sqlite3BtreeNext );
   assert( pOp->opcode!=OP_PrevIfOpen || pOp->p4.xAdvance==sqlite3BtreePrevious);
   rc = pOp->p4.xAdvance(pC->pCursor, &res);
 next_tail:
   pC->cacheStatus = CACHE_STALE;
   VdbeBranchTaken(res==0,2);
   if( res==0 ){
     pC->nullRow = 0;
     pc = pOp->p2 - 1;
     p->aCounter[pOp->p5]++;
 #ifdef SQLITE_TEST
     sqlite3_search_count++;
 #endif
   }else{
     pC->nullRow = 1;
   }
   u.br.pC->rowidIsValid = 0;
   pC->rowidIsValid = 0;
   goto check_for_interrupt;
 }
 /* Opcode: IdxInsert P1 P2 P3 * P5
 ** Synopsis: key=r[P2]
 **
 ** Register P2 holds an SQL index key made using the
 ** MakeRecord instructions.  This opcode writes that key

@@ -70767,84 +71653,90 @@ case OP_Next: { /* jump */

 ** P3 is a flag that provides a hint to the b-tree layer that this
 ** insert is likely to be an append.
 **
 ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
 ** incremented by this instruction.  If the OPFLAG_NCHANGE bit is clear,
 ** then the change counter is unchanged.
 **
 ** If P5 has the OPFLAG_USESEEKRESULT bit set, then the cursor must have
 ** just done a seek to the spot where the new entry is to be inserted.
 ** This flag avoids doing an extra seek.
 **
 ** This instruction only works for indices.  The equivalent instruction
 ** for tables is OP_Insert.
 */
 case OP_SorterInsert:       /* in2 */
 case OP_IdxInsert: {        /* in2 */
 #if 0  /* local variables moved into u.bs */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   int nKey;
   const char *zKey;
 #endif /* local variables moved into u.bs */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bs.pC = p->apCsr[pOp->p1];
   assert( u.bs.pC!=0 );
   assert( u.bs.pC->isSorter==(pOp->opcode==OP_SorterInsert) );
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) );
   pIn2 = &aMem[pOp->p2];
   assert( pIn2->flags & MEM_Blob );
   u.bs.pCrsr = u.bs.pC->pCursor;
   if( ALWAYS(u.bs.pCrsr!=0) ){
     assert( u.bs.pC->isTable==0 );
     rc = ExpandBlob(pIn2);
     if( rc==SQLITE_OK ){
       if( isSorter(u.bs.pC) ){
         rc = sqlite3VdbeSorterWrite(db, u.bs.pC, pIn2);
       }else{
         u.bs.nKey = pIn2->n;
         u.bs.zKey = pIn2->z;
         rc = sqlite3BtreeInsert(u.bs.pCrsr, u.bs.zKey, u.bs.nKey, "", 0, 0, pOp->p3,
             ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bs.pC->seekResult : 0)
             );
         assert( u.bs.pC->deferredMoveto==0 );
         u.bs.pC->cacheStatus = CACHE_STALE;
       }
   pCrsr = pC->pCursor;
   if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
   assert( pCrsr!=0 );
   assert( pC->isTable==0 );
   rc = ExpandBlob(pIn2);
   if( rc==SQLITE_OK ){
     if( isSorter(pC) ){
       rc = sqlite3VdbeSorterWrite(db, pC, pIn2);
     }else{
       nKey = pIn2->n;
       zKey = pIn2->z;
       rc = sqlite3BtreeInsert(pCrsr, zKey, nKey, "", 0, 0, pOp->p3,
           ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
           );
       assert( pC->deferredMoveto==0 );
       pC->cacheStatus = CACHE_STALE;
     }
   }
   break;
 }
 /* Opcode: IdxDelete P1 P2 P3 * *
 ** Synopsis: key=r[P2@P3]
 **
 ** The content of P3 registers starting at register P2 form
 ** an unpacked index key. This opcode removes that entry from the
 ** index opened by cursor P1.
 */
 case OP_IdxDelete: {
 #if 0  /* local variables moved into u.bt */
   VdbeCursor *pC;
   BtCursor *pCrsr;
   int res;
   UnpackedRecord r;
 #endif /* local variables moved into u.bt */
   assert( pOp->p3>0 );
   assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem-p->nCursor)+1 );
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bt.pC = p->apCsr[pOp->p1];
   assert( u.bt.pC!=0 );
   u.bt.pCrsr = u.bt.pC->pCursor;
   if( ALWAYS(u.bt.pCrsr!=0) ){
     u.bt.r.pKeyInfo = u.bt.pC->pKeyInfo;
     u.bt.r.nField = (u16)pOp->p3;
     u.bt.r.flags = 0;
     u.bt.r.aMem = &aMem[pOp->p2];
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   pCrsr = pC->pCursor;
   assert( pCrsr!=0 );
   assert( pOp->p5==0 );
   r.pKeyInfo = pC->pKeyInfo;
   r.nField = (u16)pOp->p3;
   r.default_rc = 0;
   r.aMem = &aMem[pOp->p2];
 #ifdef SQLITE_DEBUG
     { int i; for(i=0; i<u.bt.r.nField; i++) assert( memIsValid(&u.bt.r.aMem[i]) ); }
   { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
 #endif
     rc = sqlite3BtreeMovetoUnpacked(u.bt.pCrsr, &u.bt.r, 0, 0, &u.bt.res);
     if( rc==SQLITE_OK && u.bt.res==0 ){
       rc = sqlite3BtreeDelete(u.bt.pCrsr);
     }
     assert( u.bt.pC->deferredMoveto==0 );
     u.bt.pC->cacheStatus = CACHE_STALE;
   rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res);
   if( rc==SQLITE_OK && res==0 ){
     rc = sqlite3BtreeDelete(pCrsr);
   }
   assert( pC->deferredMoveto==0 );
   pC->cacheStatus = CACHE_STALE;
   break;
 }
 /* Opcode: IdxRowid P1 P2 * * *
 ** Synopsis: r[P2]=rowid
 **
 ** Write into register P2 an integer which is the last entry in the record at
 ** the end of the index key pointed to by cursor P1.  This integer should be

@@ -70853,97 +71745,118 @@ case OP_IdxDelete: {

 ** See also: Rowid, MakeRecord.
 */
 case OP_IdxRowid: {              /* out2-prerelease */
 #if 0  /* local variables moved into u.bu */
   BtCursor *pCrsr;
   VdbeCursor *pC;
   i64 rowid;
 #endif /* local variables moved into u.bu */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bu.pC = p->apCsr[pOp->p1];
   assert( u.bu.pC!=0 );
   u.bu.pCrsr = u.bu.pC->pCursor;
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   pCrsr = pC->pCursor;
   assert( pCrsr!=0 );
   pOut->flags = MEM_Null;
   if( ALWAYS(u.bu.pCrsr!=0) ){
     rc = sqlite3VdbeCursorMoveto(u.bu.pC);
     if( NEVER(rc) ) goto abort_due_to_error;
     assert( u.bu.pC->deferredMoveto==0 );
     assert( u.bu.pC->isTable==0 );
     if( !u.bu.pC->nullRow ){
       rc = sqlite3VdbeIdxRowid(db, u.bu.pCrsr, &u.bu.rowid);
       if( rc!=SQLITE_OK ){
         goto abort_due_to_error;
       }
       pOut->u.i = u.bu.rowid;
       pOut->flags = MEM_Int;
   rc = sqlite3VdbeCursorMoveto(pC);
   if( NEVER(rc) ) goto abort_due_to_error;
   assert( pC->deferredMoveto==0 );
   assert( pC->isTable==0 );
   if( !pC->nullRow ){
     rowid = 0;  /* Not needed.  Only used to silence a warning. */
     rc = sqlite3VdbeIdxRowid(db, pCrsr, &rowid);
     if( rc!=SQLITE_OK ){
       goto abort_due_to_error;
     }
     pOut->u.i = rowid;
     pOut->flags = MEM_Int;
   }
   break;
 }
 /* Opcode: IdxGE P1 P2 P3 P4 P5
 ** Synopsis: key=r[P3@P4]
 **
 ** The P4 register values beginning with P3 form an unpacked index
 ** key that omits the ROWID.  Compare this key value against the index
 ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
 ** key that omits the PRIMARY KEY.  Compare this key value against the index
 ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID
 ** fields at the end.
 **
 ** If the P1 index entry is greater than or equal to the key value
 ** then jump to P2.  Otherwise fall through to the next instruction.
 */
 /* Opcode: IdxGT P1 P2 P3 P4 P5
 ** Synopsis: key=r[P3@P4]
 **
 ** The P4 register values beginning with P3 form an unpacked index
 ** key that omits the PRIMARY KEY.  Compare this key value against the index
 ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID
 ** fields at the end.
 **
 ** If P5 is non-zero then the key value is increased by an epsilon
 ** prior to the comparison.  This make the opcode work like IdxGT except
 ** that if the key from register P3 is a prefix of the key in the cursor,
 ** the result is false whereas it would be true with IdxGT.
 ** If the P1 index entry is greater than the key value
 ** then jump to P2.  Otherwise fall through to the next instruction.
 */
 /* Opcode: IdxLT P1 P2 P3 P4 P5
 ** Synopsis: key=r[P3@P4]
 **
 ** The P4 register values beginning with P3 form an unpacked index
 ** key that omits the ROWID.  Compare this key value against the index
 ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
 ** key that omits the PRIMARY KEY or ROWID.  Compare this key value against
 ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
 ** ROWID on the P1 index.
 **
 ** If the P1 index entry is less than the key value then jump to P2.
 ** Otherwise fall through to the next instruction.
 */
 /* Opcode: IdxLE P1 P2 P3 P4 P5
 ** Synopsis: key=r[P3@P4]
 **
 ** The P4 register values beginning with P3 form an unpacked index
 ** key that omits the PRIMARY KEY or ROWID.  Compare this key value against
 ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
 ** ROWID on the P1 index.
 **
 ** If P5 is non-zero then the key value is increased by an epsilon prior
 ** to the comparison.  This makes the opcode work like IdxLE.
 ** If the P1 index entry is less than or equal to the key value then jump
 ** to P2. Otherwise fall through to the next instruction.
 */
 case OP_IdxLE:          /* jump */
 case OP_IdxGT:          /* jump */
 case OP_IdxLT:          /* jump */
 case OP_IdxGE: {        /* jump */
 #if 0  /* local variables moved into u.bv */
 case OP_IdxGE:  {       /* jump */
   VdbeCursor *pC;
   int res;
   UnpackedRecord r;
 #endif /* local variables moved into u.bv */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   u.bv.pC = p->apCsr[pOp->p1];
   assert( u.bv.pC!=0 );
   assert( u.bv.pC->isOrdered );
   if( ALWAYS(u.bv.pC->pCursor!=0) ){
     assert( u.bv.pC->deferredMoveto==0 );
     assert( pOp->p5==0 || pOp->p5==1 );
     assert( pOp->p4type==P4_INT32 );
     u.bv.r.pKeyInfo = u.bv.pC->pKeyInfo;
     u.bv.r.nField = (u16)pOp->p4.i;
     if( pOp->p5 ){
       u.bv.r.flags = UNPACKED_INCRKEY | UNPACKED_PREFIX_MATCH;
     }else{
       u.bv.r.flags = UNPACKED_PREFIX_MATCH;
     }
     u.bv.r.aMem = &aMem[pOp->p3];
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( pC->isOrdered );
   assert( pC->pCursor!=0);
   assert( pC->deferredMoveto==0 );
   assert( pOp->p5==0 || pOp->p5==1 );
   assert( pOp->p4type==P4_INT32 );
   r.pKeyInfo = pC->pKeyInfo;
   r.nField = (u16)pOp->p4.i;
   if( pOp->opcode<OP_IdxLT ){
     assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT );
     r.default_rc = -1;
   }else{
     assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT );
     r.default_rc = 0;
   }
   r.aMem = &aMem[pOp->p3];
 #ifdef SQLITE_DEBUG
     { int i; for(i=0; i<u.bv.r.nField; i++) assert( memIsValid(&u.bv.r.aMem[i]) ); }
   { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
 #endif
     rc = sqlite3VdbeIdxKeyCompare(u.bv.pC, &u.bv.r, &u.bv.res);
     if( pOp->opcode==OP_IdxLT ){
       u.bv.res = -u.bv.res;
     }else{
       assert( pOp->opcode==OP_IdxGE );
       u.bv.res++;
     }
     if( u.bv.res>0 ){
       pc = pOp->p2 - 1 ;
     }
   res = 0;  /* Not needed.  Only used to silence a warning. */
   rc = sqlite3VdbeIdxKeyCompare(pC, &r, &res);
   assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) );
   if( (pOp->opcode&1)==(OP_IdxLT&1) ){
     assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT );
     res = -res;
   }else{
     assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT );
     res++;
   }
   VdbeBranchTaken(res>0,2);
   if( res>0 ){
     pc = pOp->p2 - 1 ;
   }
   break;
 }

@@ -70969,43 +71882,42 @@ case OP_IdxGE: { /* jump */

 ** See also: Clear
 */
 case OP_Destroy: {     /* out2-prerelease */
 #if 0  /* local variables moved into u.bw */
   int iMoved;
   int iCnt;
   Vdbe *pVdbe;
   int iDb;
 #endif /* local variables moved into u.bw */
   assert( p->readOnly==0 );
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   u.bw.iCnt = 0;
   for(u.bw.pVdbe=db->pVdbe; u.bw.pVdbe; u.bw.pVdbe = u.bw.pVdbe->pNext){
     if( u.bw.pVdbe->magic==VDBE_MAGIC_RUN && u.bw.pVdbe->bIsReader
      && u.bw.pVdbe->inVtabMethod<2 && u.bw.pVdbe->pc>=0
   iCnt = 0;
   for(pVdbe=db->pVdbe; pVdbe; pVdbe = pVdbe->pNext){
     if( pVdbe->magic==VDBE_MAGIC_RUN && pVdbe->bIsReader
      && pVdbe->inVtabMethod<2 && pVdbe->pc>=0
     ){
       u.bw.iCnt++;
       iCnt++;
     }
   }
 #else
   u.bw.iCnt = db->nVdbeRead;
   iCnt = db->nVdbeRead;
 #endif
   pOut->flags = MEM_Null;
   if( u.bw.iCnt>1 ){
   if( iCnt>1 ){
     rc = SQLITE_LOCKED;
     p->errorAction = OE_Abort;
   }else{
     u.bw.iDb = pOp->p3;
     assert( u.bw.iCnt==1 );
     assert( (p->btreeMask & (((yDbMask)1)<<u.bw.iDb))!=0 );
     rc = sqlite3BtreeDropTable(db->aDb[u.bw.iDb].pBt, pOp->p1, &u.bw.iMoved);
     iDb = pOp->p3;
     assert( iCnt==1 );
     assert( (p->btreeMask & (((yDbMask)1)<<iDb))!=0 );
     iMoved = 0;  /* Not needed.  Only to silence a warning. */
     rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
     pOut->flags = MEM_Int;
     pOut->u.i = u.bw.iMoved;
     pOut->u.i = iMoved;
 #ifndef SQLITE_OMIT_AUTOVACUUM
     if( rc==SQLITE_OK && u.bw.iMoved!=0 ){
       sqlite3RootPageMoved(db, u.bw.iDb, u.bw.iMoved, pOp->p1);
     if( rc==SQLITE_OK && iMoved!=0 ){
       sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
       /* All OP_Destroy operations occur on the same btree */
       assert( resetSchemaOnFault==0 || resetSchemaOnFault==u.bw.iDb+1 );
       resetSchemaOnFault = u.bw.iDb+1;
       assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
       resetSchemaOnFault = iDb+1;
     }
 #endif
   }

@@ -71031,29 +71943,27 @@ case OP_Destroy: { /* out2-prerelease */

 ** See also: Destroy
 */
 case OP_Clear: {
 #if 0  /* local variables moved into u.bx */
   int nChange;
 #endif /* local variables moved into u.bx */
   u.bx.nChange = 0;
   nChange = 0;
   assert( p->readOnly==0 );
   assert( pOp->p1!=1 );
   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
   rc = sqlite3BtreeClearTable(
       db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &u.bx.nChange : 0)
       db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &nChange : 0)
   );
   if( pOp->p3 ){
     p->nChange += u.bx.nChange;
     p->nChange += nChange;
     if( pOp->p3>0 ){
       assert( memIsValid(&aMem[pOp->p3]) );
       memAboutToChange(p, &aMem[pOp->p3]);
       aMem[pOp->p3].u.i += u.bx.nChange;
       aMem[pOp->p3].u.i += nChange;
     }
   }
   break;
 }
 /* Opcode: CreateTable P1 P2 * * *
 ** Synopsis: r[P2]=root iDb=P1
 **
 ** Allocate a new table in the main database file if P1==0 or in the
 ** auxiliary database file if P1==1 or in an attached database if

@@ -71067,6 +71977,7 @@ case OP_Clear: {

 ** See also: CreateIndex
 */
 /* Opcode: CreateIndex P1 P2 * * *
 ** Synopsis: r[P2]=root iDb=P1
 **
 ** Allocate a new index in the main database file if P1==0 or in the
 ** auxiliary database file if P1==1 or in an attached database if

@@ -71077,26 +71988,24 @@ case OP_Clear: {

 */
 case OP_CreateIndex:            /* out2-prerelease */
 case OP_CreateTable: {          /* out2-prerelease */
 #if 0  /* local variables moved into u.by */
   int pgno;
   int flags;
   Db *pDb;
 #endif /* local variables moved into u.by */
   u.by.pgno = 0;
   pgno = 0;
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
   assert( p->readOnly==0 );
   u.by.pDb = &db->aDb[pOp->p1];
   assert( u.by.pDb->pBt!=0 );
   pDb = &db->aDb[pOp->p1];
   assert( pDb->pBt!=0 );
   if( pOp->opcode==OP_CreateTable ){
     /* u.by.flags = BTREE_INTKEY; */
     u.by.flags = BTREE_INTKEY;
     /* flags = BTREE_INTKEY; */
     flags = BTREE_INTKEY;
   }else{
     u.by.flags = BTREE_BLOBKEY;
     flags = BTREE_BLOBKEY;
   }
   rc = sqlite3BtreeCreateTable(u.by.pDb->pBt, &u.by.pgno, u.by.flags);
   pOut->u.i = u.by.pgno;
   rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
   pOut->u.i = pgno;
   break;
 }

@@ -71109,44 +72018,42 @@ case OP_CreateTable: { /* out2-prerelease */

 ** then runs the new virtual machine.  It is thus a re-entrant opcode.
 */
 case OP_ParseSchema: {
 #if 0  /* local variables moved into u.bz */
   int iDb;
   const char *zMaster;
   char *zSql;
   InitData initData;
 #endif /* local variables moved into u.bz */
   /* Any prepared statement that invokes this opcode will hold mutexes
   ** on every btree.  This is a prerequisite for invoking
   ** on every btree.  This is a prerequisite for invoking
   ** sqlite3InitCallback().
   */
 #ifdef SQLITE_DEBUG
   for(u.bz.iDb=0; u.bz.iDb<db->nDb; u.bz.iDb++){
     assert( u.bz.iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[u.bz.iDb].pBt) );
   for(iDb=0; iDb<db->nDb; iDb++){
     assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
   }
 #endif
   u.bz.iDb = pOp->p1;
   assert( u.bz.iDb>=0 && u.bz.iDb<db->nDb );
   assert( DbHasProperty(db, u.bz.iDb, DB_SchemaLoaded) );
   iDb = pOp->p1;
   assert( iDb>=0 && iDb<db->nDb );
   assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
   /* Used to be a conditional */ {
     u.bz.zMaster = SCHEMA_TABLE(u.bz.iDb);
     u.bz.initData.db = db;
     u.bz.initData.iDb = pOp->p1;
     u.bz.initData.pzErrMsg = &p->zErrMsg;
     u.bz.zSql = sqlite3MPrintf(db,
     zMaster = SCHEMA_TABLE(iDb);
     initData.db = db;
     initData.iDb = pOp->p1;
     initData.pzErrMsg = &p->zErrMsg;
     zSql = sqlite3MPrintf(db,
        "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s ORDER BY rowid",
        db->aDb[u.bz.iDb].zName, u.bz.zMaster, pOp->p4.z);
     if( u.bz.zSql==0 ){
        db->aDb[iDb].zName, zMaster, pOp->p4.z);
     if( zSql==0 ){
       rc = SQLITE_NOMEM;
     }else{
       assert( db->init.busy==0 );
       db->init.busy = 1;
       u.bz.initData.rc = SQLITE_OK;
       initData.rc = SQLITE_OK;
       assert( !db->mallocFailed );
       rc = sqlite3_exec(db, u.bz.zSql, sqlite3InitCallback, &u.bz.initData, 0);
       if( rc==SQLITE_OK ) rc = u.bz.initData.rc;
       sqlite3DbFree(db, u.bz.zSql);
       rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
       if( rc==SQLITE_OK ) rc = initData.rc;
       sqlite3DbFree(db, zSql);
       db->init.busy = 0;
     }
   }

@@ -71154,7 +72061,7 @@ case OP_ParseSchema: {

   if( rc==SQLITE_NOMEM ){
     goto no_mem;
   }
   break;
   break;
 }
 #if !defined(SQLITE_OMIT_ANALYZE)

@@ -71230,42 +72137,40 @@ case OP_DropTrigger: {

 ** This opcode is used to implement the integrity_check pragma.
 */
 case OP_IntegrityCk: {
 #if 0  /* local variables moved into u.ca */
   int nRoot;      /* Number of tables to check.  (Number of root pages.) */
   int *aRoot;     /* Array of rootpage numbers for tables to be checked */
   int j;          /* Loop counter */
   int nErr;       /* Number of errors reported */
   char *z;        /* Text of the error report */
   Mem *pnErr;     /* Register keeping track of errors remaining */
 #endif /* local variables moved into u.ca */
   assert( p->bIsReader );
   u.ca.nRoot = pOp->p2;
   assert( u.ca.nRoot>0 );
   u.ca.aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(u.ca.nRoot+1) );
   if( u.ca.aRoot==0 ) goto no_mem;
   nRoot = pOp->p2;
   assert( nRoot>0 );
   aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(nRoot+1) );
   if( aRoot==0 ) goto no_mem;
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   u.ca.pnErr = &aMem[pOp->p3];
   assert( (u.ca.pnErr->flags & MEM_Int)!=0 );
   assert( (u.ca.pnErr->flags & (MEM_Str|MEM_Blob))==0 );
   pnErr = &aMem[pOp->p3];
   assert( (pnErr->flags & MEM_Int)!=0 );
   assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
   pIn1 = &aMem[pOp->p1];
   for(u.ca.j=0; u.ca.j<u.ca.nRoot; u.ca.j++){
     u.ca.aRoot[u.ca.j] = (int)sqlite3VdbeIntValue(&pIn1[u.ca.j]);
   for(j=0; j<nRoot; j++){
     aRoot[j] = (int)sqlite3VdbeIntValue(&pIn1[j]);
   }
   u.ca.aRoot[u.ca.j] = 0;
   aRoot[j] = 0;
   assert( pOp->p5<db->nDb );
   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p5))!=0 );
   u.ca.z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, u.ca.aRoot, u.ca.nRoot,
                                  (int)u.ca.pnErr->u.i, &u.ca.nErr);
   sqlite3DbFree(db, u.ca.aRoot);
   u.ca.pnErr->u.i -= u.ca.nErr;
   z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot,
                                  (int)pnErr->u.i, &nErr);
   sqlite3DbFree(db, aRoot);
   pnErr->u.i -= nErr;
   sqlite3VdbeMemSetNull(pIn1);
   if( u.ca.nErr==0 ){
     assert( u.ca.z==0 );
   }else if( u.ca.z==0 ){
   if( nErr==0 ){
     assert( z==0 );
   }else if( z==0 ){
     goto no_mem;
   }else{
     sqlite3VdbeMemSetStr(pIn1, u.ca.z, -1, SQLITE_UTF8, sqlite3_free);
     sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
   }
   UPDATE_MAX_BLOBSIZE(pIn1);
   sqlite3VdbeChangeEncoding(pIn1, encoding);

@@ -71274,6 +72179,7 @@ case OP_IntegrityCk: {

 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
 /* Opcode: RowSetAdd P1 P2 * * *
 ** Synopsis:  rowset(P1)=r[P2]
 **
 ** Insert the integer value held by register P2 into a boolean index
 ** held in register P1.

@@ -71293,31 +72199,33 @@ case OP_RowSetAdd: { /* in1, in2 */

 }
 /* Opcode: RowSetRead P1 P2 P3 * *
 ** Synopsis:  r[P3]=rowset(P1)
 **
 ** Extract the smallest value from boolean index P1 and put that value into
 ** register P3.  Or, if boolean index P1 is initially empty, leave P3
 ** unchanged and jump to instruction P2.
 */
 case OP_RowSetRead: {       /* jump, in1, out3 */
 #if 0  /* local variables moved into u.cb */
   i64 val;
 #endif /* local variables moved into u.cb */
   pIn1 = &aMem[pOp->p1];
   if( (pIn1->flags & MEM_RowSet)==0
    || sqlite3RowSetNext(pIn1->u.pRowSet, &u.cb.val)==0
   if( (pIn1->flags & MEM_RowSet)==0
    || sqlite3RowSetNext(pIn1->u.pRowSet, &val)==0
   ){
     /* The boolean index is empty */
     sqlite3VdbeMemSetNull(pIn1);
     pc = pOp->p2 - 1;
     VdbeBranchTaken(1,2);
   }else{
     /* A value was pulled from the index */
     sqlite3VdbeMemSetInt64(&aMem[pOp->p3], u.cb.val);
     sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val);
     VdbeBranchTaken(0,2);
   }
   goto check_for_interrupt;
 }
 /* Opcode: RowSetTest P1 P2 P3 P4
 ** Synopsis: if r[P3] in rowset(P1) goto P2
 **
 ** Register P3 is assumed to hold a 64-bit integer value. If register P1
 ** contains a RowSet object and that RowSet object contains

@@ -71341,14 +72249,12 @@ case OP_RowSetRead: { /* jump, in1, out3 */

 ** inserted as part of some other set).
 */
 case OP_RowSetTest: {                     /* jump, in1, in3 */
 #if 0  /* local variables moved into u.cc */
   int iSet;
   int exists;
 #endif /* local variables moved into u.cc */
   pIn1 = &aMem[pOp->p1];
   pIn3 = &aMem[pOp->p3];
   u.cc.iSet = pOp->p4.i;
   iSet = pOp->p4.i;
   assert( pIn3->flags&MEM_Int );
   /* If there is anything other than a rowset object in memory cell P1,

@@ -71360,17 +72266,18 @@ case OP_RowSetTest: { /* jump, in1, in3 */

   }
   assert( pOp->p4type==P4_INT32 );
   assert( u.cc.iSet==-1 || u.cc.iSet>=0 );
   if( u.cc.iSet ){
     u.cc.exists = sqlite3RowSetTest(pIn1->u.pRowSet,
                                (u8)(u.cc.iSet>=0 ? u.cc.iSet & 0xf : 0xff),
   assert( iSet==-1 || iSet>=0 );
   if( iSet ){
     exists = sqlite3RowSetTest(pIn1->u.pRowSet,
                                (u8)(iSet>=0 ? iSet & 0xf : 0xff),
                                pIn3->u.i);
     if( u.cc.exists ){
     VdbeBranchTaken(exists!=0,2);
     if( exists ){
       pc = pOp->p2 - 1;
       break;
     }
   }
   if( u.cc.iSet>=0 ){
   if( iSet>=0 ){
     sqlite3RowSetInsert(pIn1->u.pRowSet, pIn3->u.i);
   }
   break;

@@ -71379,7 +72286,7 @@ case OP_RowSetTest: { /* jump, in1, in3 */

 #ifndef SQLITE_OMIT_TRIGGER
 /* Opcode: Program P1 P2 P3 P4 *
 /* Opcode: Program P1 P2 P3 P4 P5
 **
 ** Execute the trigger program passed as P4 (type P4_SUBPROGRAM).
 **

@@ -71391,9 +72298,10 @@ case OP_RowSetTest: { /* jump, in1, in3 */

 ** memory required by the sub-vdbe at runtime.
 **
 ** P4 is a pointer to the VM containing the trigger program.
 **
 ** If P5 is non-zero, then recursive program invocation is enabled.
 */
 case OP_Program: {        /* jump */
 #if 0  /* local variables moved into u.cd */
   int nMem;               /* Number of memory registers for sub-program */
   int nByte;              /* Bytes of runtime space required for sub-program */
   Mem *pRt;               /* Register to allocate runtime space */

@@ -71402,27 +72310,26 @@ case OP_Program: { /* jump */

   VdbeFrame *pFrame;      /* New vdbe frame to execute in */
   SubProgram *pProgram;   /* Sub-program to execute */
   void *t;                /* Token identifying trigger */
 #endif /* local variables moved into u.cd */
   u.cd.pProgram = pOp->p4.pProgram;
   u.cd.pRt = &aMem[pOp->p3];
   assert( u.cd.pProgram->nOp>0 );
   /* If the p5 flag is clear, then recursive invocation of triggers is
   pProgram = pOp->p4.pProgram;
   pRt = &aMem[pOp->p3];
   assert( pProgram->nOp>0 );
   /* If the p5 flag is clear, then recursive invocation of triggers is
   ** disabled for backwards compatibility (p5 is set if this sub-program
   ** is really a trigger, not a foreign key action, and the flag set
   ** and cleared by the "PRAGMA recursive_triggers" command is clear).
   **
   ** It is recursive invocation of triggers, at the SQL level, that is
   ** disabled. In some cases a single trigger may generate more than one
   ** SubProgram (if the trigger may be executed with more than one different
   **
   ** It is recursive invocation of triggers, at the SQL level, that is
   ** disabled. In some cases a single trigger may generate more than one
   ** SubProgram (if the trigger may be executed with more than one different
   ** ON CONFLICT algorithm). SubProgram structures associated with a
   ** single trigger all have the same value for the SubProgram.token
   ** single trigger all have the same value for the SubProgram.token
   ** variable.  */
   if( pOp->p5 ){
     u.cd.t = u.cd.pProgram->token;
     for(u.cd.pFrame=p->pFrame; u.cd.pFrame && u.cd.pFrame->token!=u.cd.t; u.cd.pFrame=u.cd.pFrame->pParent);
     if( u.cd.pFrame ) break;
     t = pProgram->token;
     for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent);
     if( pFrame ) break;
   }
   if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){

@@ -71431,69 +72338,69 @@ case OP_Program: { /* jump */

     break;
   }
   /* Register u.cd.pRt is used to store the memory required to save the state
   /* Register pRt is used to store the memory required to save the state
   ** of the current program, and the memory required at runtime to execute
   ** the trigger program. If this trigger has been fired before, then u.cd.pRt
   ** the trigger program. If this trigger has been fired before, then pRt
   ** is already allocated. Otherwise, it must be initialized.  */
   if( (u.cd.pRt->flags&MEM_Frame)==0 ){
     /* SubProgram.nMem is set to the number of memory cells used by the
   if( (pRt->flags&MEM_Frame)==0 ){
     /* SubProgram.nMem is set to the number of memory cells used by the
     ** program stored in SubProgram.aOp. As well as these, one memory
     ** cell is required for each cursor used by the program. Set local
     ** variable u.cd.nMem (and later, VdbeFrame.nChildMem) to this value.
     ** variable nMem (and later, VdbeFrame.nChildMem) to this value.
     */
     u.cd.nMem = u.cd.pProgram->nMem + u.cd.pProgram->nCsr;
     u.cd.nByte = ROUND8(sizeof(VdbeFrame))
               + u.cd.nMem * sizeof(Mem)
               + u.cd.pProgram->nCsr * sizeof(VdbeCursor *)
               + u.cd.pProgram->nOnce * sizeof(u8);
     u.cd.pFrame = sqlite3DbMallocZero(db, u.cd.nByte);
     if( !u.cd.pFrame ){
     nMem = pProgram->nMem + pProgram->nCsr;
     nByte = ROUND8(sizeof(VdbeFrame))
               + nMem * sizeof(Mem)
               + pProgram->nCsr * sizeof(VdbeCursor *)
               + pProgram->nOnce * sizeof(u8);
     pFrame = sqlite3DbMallocZero(db, nByte);
     if( !pFrame ){
       goto no_mem;
     }
     sqlite3VdbeMemRelease(u.cd.pRt);
     u.cd.pRt->flags = MEM_Frame;
     u.cd.pRt->u.pFrame = u.cd.pFrame;
     sqlite3VdbeMemRelease(pRt);
     pRt->flags = MEM_Frame;
     pRt->u.pFrame = pFrame;
     u.cd.pFrame->v = p;
     u.cd.pFrame->nChildMem = u.cd.nMem;
     u.cd.pFrame->nChildCsr = u.cd.pProgram->nCsr;
     u.cd.pFrame->pc = pc;
     u.cd.pFrame->aMem = p->aMem;
     u.cd.pFrame->nMem = p->nMem;
     u.cd.pFrame->apCsr = p->apCsr;
     u.cd.pFrame->nCursor = p->nCursor;
     u.cd.pFrame->aOp = p->aOp;
     u.cd.pFrame->nOp = p->nOp;
     u.cd.pFrame->token = u.cd.pProgram->token;
     u.cd.pFrame->aOnceFlag = p->aOnceFlag;
     u.cd.pFrame->nOnceFlag = p->nOnceFlag;
     pFrame->v = p;
     pFrame->nChildMem = nMem;
     pFrame->nChildCsr = pProgram->nCsr;
     pFrame->pc = pc;
     pFrame->aMem = p->aMem;
     pFrame->nMem = p->nMem;
     pFrame->apCsr = p->apCsr;
     pFrame->nCursor = p->nCursor;
     pFrame->aOp = p->aOp;
     pFrame->nOp = p->nOp;
     pFrame->token = pProgram->token;
     pFrame->aOnceFlag = p->aOnceFlag;
     pFrame->nOnceFlag = p->nOnceFlag;
     u.cd.pEnd = &VdbeFrameMem(u.cd.pFrame)[u.cd.pFrame->nChildMem];
     for(u.cd.pMem=VdbeFrameMem(u.cd.pFrame); u.cd.pMem!=u.cd.pEnd; u.cd.pMem++){
       u.cd.pMem->flags = MEM_Invalid;
       u.cd.pMem->db = db;
     pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem];
     for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){
       pMem->flags = MEM_Undefined;
       pMem->db = db;
     }
   }else{
     u.cd.pFrame = u.cd.pRt->u.pFrame;
     assert( u.cd.pProgram->nMem+u.cd.pProgram->nCsr==u.cd.pFrame->nChildMem );
     assert( u.cd.pProgram->nCsr==u.cd.pFrame->nChildCsr );
     assert( pc==u.cd.pFrame->pc );
     pFrame = pRt->u.pFrame;
     assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem );
     assert( pProgram->nCsr==pFrame->nChildCsr );
     assert( pc==pFrame->pc );
   }
   p->nFrame++;
   u.cd.pFrame->pParent = p->pFrame;
   u.cd.pFrame->lastRowid = lastRowid;
   u.cd.pFrame->nChange = p->nChange;
   pFrame->pParent = p->pFrame;
   pFrame->lastRowid = lastRowid;
   pFrame->nChange = p->nChange;
   p->nChange = 0;
   p->pFrame = u.cd.pFrame;
   p->aMem = aMem = &VdbeFrameMem(u.cd.pFrame)[-1];
   p->nMem = u.cd.pFrame->nChildMem;
   p->nCursor = (u16)u.cd.pFrame->nChildCsr;
   p->pFrame = pFrame;
   p->aMem = aMem = &VdbeFrameMem(pFrame)[-1];
   p->nMem = pFrame->nChildMem;
   p->nCursor = (u16)pFrame->nChildCsr;
   p->apCsr = (VdbeCursor **)&aMem[p->nMem+1];
   p->aOp = aOp = u.cd.pProgram->aOp;
   p->nOp = u.cd.pProgram->nOp;
   p->aOp = aOp = pProgram->aOp;
   p->nOp = pProgram->nOp;
   p->aOnceFlag = (u8 *)&p->apCsr[p->nCursor];
   p->nOnceFlag = u.cd.pProgram->nOnce;
   p->nOnceFlag = pProgram->nOnce;
   pc = -1;
   memset(p->aOnceFlag, 0, p->nOnceFlag);

@@ -71513,13 +72420,11 @@ case OP_Program: { /* jump */

 ** calling OP_Program instruction.
 */
 case OP_Param: {           /* out2-prerelease */
 #if 0  /* local variables moved into u.ce */
   VdbeFrame *pFrame;
   Mem *pIn;
 #endif /* local variables moved into u.ce */
   u.ce.pFrame = p->pFrame;
   u.ce.pIn = &u.ce.pFrame->aMem[pOp->p1 + u.ce.pFrame->aOp[u.ce.pFrame->pc].p1];
   sqlite3VdbeMemShallowCopy(pOut, u.ce.pIn, MEM_Ephem);
   pFrame = p->pFrame;
   pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];
   sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem);
   break;
 }

@@ -71527,6 +72432,7 @@ case OP_Param: { /* out2-prerelease */

 #ifndef SQLITE_OMIT_FOREIGN_KEY
 /* Opcode: FkCounter P1 P2 * * *
 ** Synopsis: fkctr[P1]+=P2
 **
 ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
 ** If P1 is non-zero, the database constraint counter is incremented

@@ -71545,6 +72451,7 @@ case OP_FkCounter: {

 }
 /* Opcode: FkIfZero P1 P2 * * *
 ** Synopsis: if fkctr[P1]==0 goto P2
 **
 ** This opcode tests if a foreign key constraint-counter is currently zero.
 ** If so, jump to instruction P2. Otherwise, fall through to the next

@@ -71557,8 +72464,10 @@ case OP_FkCounter: {

 */
 case OP_FkIfZero: {         /* jump */
   if( pOp->p1 ){
     VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2);
     if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) pc = pOp->p2-1;
   }else{
     VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2);
     if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) pc = pOp->p2-1;
   }
   break;

@@ -71567,6 +72476,7 @@ case OP_FkIfZero: { /* jump */

 #ifndef SQLITE_OMIT_AUTOINCREMENT
 /* Opcode: MemMax P1 P2 * * *
 ** Synopsis: r[P1]=max(r[P1],r[P2])
 **
 ** P1 is a register in the root frame of this VM (the root frame is
 ** different from the current frame if this instruction is being executed

@@ -71577,28 +72487,26 @@ case OP_FkIfZero: { /* jump */

 ** an integer.
 */
 case OP_MemMax: {        /* in2 */
 #if 0  /* local variables moved into u.cf */
   Mem *pIn1;
   VdbeFrame *pFrame;
 #endif /* local variables moved into u.cf */
   if( p->pFrame ){
     for(u.cf.pFrame=p->pFrame; u.cf.pFrame->pParent; u.cf.pFrame=u.cf.pFrame->pParent);
     u.cf.pIn1 = &u.cf.pFrame->aMem[pOp->p1];
     for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
     pIn1 = &pFrame->aMem[pOp->p1];
   }else{
     u.cf.pIn1 = &aMem[pOp->p1];
     pIn1 = &aMem[pOp->p1];
   }
   assert( memIsValid(u.cf.pIn1) );
   sqlite3VdbeMemIntegerify(u.cf.pIn1);
   assert( memIsValid(pIn1) );
   sqlite3VdbeMemIntegerify(pIn1);
   pIn2 = &aMem[pOp->p2];
   sqlite3VdbeMemIntegerify(pIn2);
   if( u.cf.pIn1->u.i<pIn2->u.i){
     u.cf.pIn1->u.i = pIn2->u.i;
   if( pIn1->u.i<pIn2->u.i){
     pIn1->u.i = pIn2->u.i;
   }
   break;
 }
 #endif /* SQLITE_OMIT_AUTOINCREMENT */
 /* Opcode: IfPos P1 P2 * * *
 ** Synopsis: if r[P1]>0 goto P2
 **
 ** If the value of register P1 is 1 or greater, jump to P2.
 **

@@ -71608,6 +72516,7 @@ case OP_MemMax: { /* in2 */

 case OP_IfPos: {        /* jump, in1 */
   pIn1 = &aMem[pOp->p1];
   assert( pIn1->flags&MEM_Int );
   VdbeBranchTaken( pIn1->u.i>0, 2);
   if( pIn1->u.i>0 ){
      pc = pOp->p2 - 1;
   }

@@ -71615,6 +72524,7 @@ case OP_IfPos: { /* jump, in1 */

 }
 /* Opcode: IfNeg P1 P2 * * *
 ** Synopsis: if r[P1]<0 goto P2
 **
 ** If the value of register P1 is less than zero, jump to P2.
 **

@@ -71624,6 +72534,7 @@ case OP_IfPos: { /* jump, in1 */

 case OP_IfNeg: {        /* jump, in1 */
   pIn1 = &aMem[pOp->p1];
   assert( pIn1->flags&MEM_Int );
   VdbeBranchTaken(pIn1->u.i<0, 2);
   if( pIn1->u.i<0 ){
      pc = pOp->p2 - 1;
   }

@@ -71631,6 +72542,7 @@ case OP_IfNeg: { /* jump, in1 */

 }
 /* Opcode: IfZero P1 P2 P3 * *
 ** Synopsis: r[P1]+=P3, if r[P1]==0 goto P2
 **
 ** The register P1 must contain an integer.  Add literal P3 to the
 ** value in register P1.  If the result is exactly 0, jump to P2.

@@ -71642,6 +72554,7 @@ case OP_IfZero: { /* jump, in1 */

   pIn1 = &aMem[pOp->p1];
   assert( pIn1->flags&MEM_Int );
   pIn1->u.i += pOp->p3;
   VdbeBranchTaken(pIn1->u.i==0, 2);
   if( pIn1->u.i==0 ){
      pc = pOp->p2 - 1;
   }

@@ -71649,6 +72562,7 @@ case OP_IfZero: { /* jump, in1 */

 }
 /* Opcode: AggStep * P2 P3 P4 P5
 ** Synopsis: accum=r[P3] step(r[P2@P5])
 **
 ** Execute the step function for an aggregate.  The
 ** function has P5 arguments.   P4 is a pointer to the FuncDef

@@ -71659,61 +72573,59 @@ case OP_IfZero: { /* jump, in1 */

 ** successors.
 */
 case OP_AggStep: {
 #if 0  /* local variables moved into u.cg */
   int n;
   int i;
   Mem *pMem;
   Mem *pRec;
   sqlite3_context ctx;
   sqlite3_value **apVal;
 #endif /* local variables moved into u.cg */
   u.cg.n = pOp->p5;
   assert( u.cg.n>=0 );
   u.cg.pRec = &aMem[pOp->p2];
   u.cg.apVal = p->apArg;
   assert( u.cg.apVal || u.cg.n==0 );
   for(u.cg.i=0; u.cg.i<u.cg.n; u.cg.i++, u.cg.pRec++){
     assert( memIsValid(u.cg.pRec) );
     u.cg.apVal[u.cg.i] = u.cg.pRec;
     memAboutToChange(p, u.cg.pRec);
     sqlite3VdbeMemStoreType(u.cg.pRec);
   }
   u.cg.ctx.pFunc = pOp->p4.pFunc;
   n = pOp->p5;
   assert( n>=0 );
   pRec = &aMem[pOp->p2];
   apVal = p->apArg;
   assert( apVal || n==0 );
   for(i=0; i<n; i++, pRec++){
     assert( memIsValid(pRec) );
     apVal[i] = pRec;
     memAboutToChange(p, pRec);
   }
   ctx.pFunc = pOp->p4.pFunc;
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   u.cg.ctx.pMem = u.cg.pMem = &aMem[pOp->p3];
   u.cg.pMem->n++;
   u.cg.ctx.s.flags = MEM_Null;
   u.cg.ctx.s.z = 0;
   u.cg.ctx.s.zMalloc = 0;
   u.cg.ctx.s.xDel = 0;
   u.cg.ctx.s.db = db;
   u.cg.ctx.isError = 0;
   u.cg.ctx.pColl = 0;
   u.cg.ctx.skipFlag = 0;
   if( u.cg.ctx.pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
   ctx.pMem = pMem = &aMem[pOp->p3];
   pMem->n++;
   ctx.s.flags = MEM_Null;
   ctx.s.z = 0;
   ctx.s.zMalloc = 0;
   ctx.s.xDel = 0;
   ctx.s.db = db;
   ctx.isError = 0;
   ctx.pColl = 0;
   ctx.skipFlag = 0;
   if( ctx.pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
     assert( pOp>p->aOp );
     assert( pOp[-1].p4type==P4_COLLSEQ );
     assert( pOp[-1].opcode==OP_CollSeq );
     u.cg.ctx.pColl = pOp[-1].p4.pColl;
     ctx.pColl = pOp[-1].p4.pColl;
   }
   (u.cg.ctx.pFunc->xStep)(&u.cg.ctx, u.cg.n, u.cg.apVal); /* IMP: R-24505-23230 */
   if( u.cg.ctx.isError ){
     sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&u.cg.ctx.s));
     rc = u.cg.ctx.isError;
   (ctx.pFunc->xStep)(&ctx, n, apVal); /* IMP: R-24505-23230 */
   if( ctx.isError ){
     sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&ctx.s));
     rc = ctx.isError;
   }
   if( u.cg.ctx.skipFlag ){
   if( ctx.skipFlag ){
     assert( pOp[-1].opcode==OP_CollSeq );
     u.cg.i = pOp[-1].p1;
     if( u.cg.i ) sqlite3VdbeMemSetInt64(&aMem[u.cg.i], 1);
     i = pOp[-1].p1;
     if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1);
   }
   sqlite3VdbeMemRelease(&u.cg.ctx.s);
   sqlite3VdbeMemRelease(&ctx.s);
   break;
 }
 /* Opcode: AggFinal P1 P2 * P4 *
 ** Synopsis: accum=r[P1] N=P2
 **
 ** Execute the finalizer function for an aggregate.  P1 is
 ** the memory location that is the accumulator for the aggregate.

@@ -71726,19 +72638,17 @@ case OP_AggStep: {

 ** the step function was not previously called.
 */
 case OP_AggFinal: {
 #if 0  /* local variables moved into u.ch */
   Mem *pMem;
 #endif /* local variables moved into u.ch */
   assert( pOp->p1>0 && pOp->p1<=(p->nMem-p->nCursor) );
   u.ch.pMem = &aMem[pOp->p1];
   assert( (u.ch.pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
   rc = sqlite3VdbeMemFinalize(u.ch.pMem, pOp->p4.pFunc);
   pMem = &aMem[pOp->p1];
   assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
   rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
   if( rc ){
     sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(u.ch.pMem));
     sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(pMem));
   }
   sqlite3VdbeChangeEncoding(u.ch.pMem, encoding);
   UPDATE_MAX_BLOBSIZE(u.ch.pMem);
   if( sqlite3VdbeMemTooBig(u.ch.pMem) ){
   sqlite3VdbeChangeEncoding(pMem, encoding);
   UPDATE_MAX_BLOBSIZE(pMem);
   if( sqlite3VdbeMemTooBig(pMem) ){
     goto too_big;
   }
   break;

@@ -71757,33 +72667,31 @@ case OP_AggFinal: {

 ** mem[P3+2] are initialized to -1.
 */
 case OP_Checkpoint: {
 #if 0  /* local variables moved into u.ci */
   int i;                          /* Loop counter */
   int aRes[3];                    /* Results */
   Mem *pMem;                      /* Write results here */
 #endif /* local variables moved into u.ci */
   assert( p->readOnly==0 );
   u.ci.aRes[0] = 0;
   u.ci.aRes[1] = u.ci.aRes[2] = -1;
   aRes[0] = 0;
   aRes[1] = aRes[2] = -1;
   assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
        || pOp->p2==SQLITE_CHECKPOINT_FULL
        || pOp->p2==SQLITE_CHECKPOINT_RESTART
   );
   rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &u.ci.aRes[1], &u.ci.aRes[2]);
   rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
   if( rc==SQLITE_BUSY ){
     rc = SQLITE_OK;
     u.ci.aRes[0] = 1;
   }
   for(u.ci.i=0, u.ci.pMem = &aMem[pOp->p3]; u.ci.i<3; u.ci.i++, u.ci.pMem++){
     sqlite3VdbeMemSetInt64(u.ci.pMem, (i64)u.ci.aRes[u.ci.i]);
     aRes[0] = 1;
   }
   for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){
     sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]);
   }
   break;
 };
 #endif
 #ifndef SQLITE_OMIT_PRAGMA
 /* Opcode: JournalMode P1 P2 P3 * P5
 /* Opcode: JournalMode P1 P2 P3 * *
 **
 ** Change the journal mode of database P1 to P3. P3 must be one of the
 ** PAGER_JOURNALMODE_XXX values. If changing between the various rollback

@@ -71795,7 +72703,6 @@ case OP_Checkpoint: {

 ** Write a string containing the final journal-mode to register P2.
 */
 case OP_JournalMode: {    /* out2-prerelease */
 #if 0  /* local variables moved into u.cj */
   Btree *pBt;                     /* Btree to change journal mode of */
   Pager *pPager;                  /* Pager associated with pBt */
   int eNew;                       /* New journal mode */

@@ -71803,86 +72710,85 @@ case OP_JournalMode: { /* out2-prerelease */

 #ifndef SQLITE_OMIT_WAL
   const char *zFilename;          /* Name of database file for pPager */
 #endif
 #endif /* local variables moved into u.cj */
   u.cj.eNew = pOp->p3;
   assert( u.cj.eNew==PAGER_JOURNALMODE_DELETE
        || u.cj.eNew==PAGER_JOURNALMODE_TRUNCATE
        || u.cj.eNew==PAGER_JOURNALMODE_PERSIST
        || u.cj.eNew==PAGER_JOURNALMODE_OFF
        || u.cj.eNew==PAGER_JOURNALMODE_MEMORY
        || u.cj.eNew==PAGER_JOURNALMODE_WAL
        || u.cj.eNew==PAGER_JOURNALMODE_QUERY
   eNew = pOp->p3;
   assert( eNew==PAGER_JOURNALMODE_DELETE
        || eNew==PAGER_JOURNALMODE_TRUNCATE
        || eNew==PAGER_JOURNALMODE_PERSIST
        || eNew==PAGER_JOURNALMODE_OFF
        || eNew==PAGER_JOURNALMODE_MEMORY
        || eNew==PAGER_JOURNALMODE_WAL
        || eNew==PAGER_JOURNALMODE_QUERY
   );
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
   assert( p->readOnly==0 );
   u.cj.pBt = db->aDb[pOp->p1].pBt;
   u.cj.pPager = sqlite3BtreePager(u.cj.pBt);
   u.cj.eOld = sqlite3PagerGetJournalMode(u.cj.pPager);
   if( u.cj.eNew==PAGER_JOURNALMODE_QUERY ) u.cj.eNew = u.cj.eOld;
   if( !sqlite3PagerOkToChangeJournalMode(u.cj.pPager) ) u.cj.eNew = u.cj.eOld;
   pBt = db->aDb[pOp->p1].pBt;
   pPager = sqlite3BtreePager(pBt);
   eOld = sqlite3PagerGetJournalMode(pPager);
   if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;
   if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
 #ifndef SQLITE_OMIT_WAL
   u.cj.zFilename = sqlite3PagerFilename(u.cj.pPager, 1);
   zFilename = sqlite3PagerFilename(pPager, 1);
   /* Do not allow a transition to journal_mode=WAL for a database
   ** in temporary storage or if the VFS does not support shared memory
   ** in temporary storage or if the VFS does not support shared memory
   */
   if( u.cj.eNew==PAGER_JOURNALMODE_WAL
    && (sqlite3Strlen30(u.cj.zFilename)==0           /* Temp file */
        || !sqlite3PagerWalSupported(u.cj.pPager))   /* No shared-memory support */
   if( eNew==PAGER_JOURNALMODE_WAL
    && (sqlite3Strlen30(zFilename)==0           /* Temp file */
        || !sqlite3PagerWalSupported(pPager))   /* No shared-memory support */
   ){
     u.cj.eNew = u.cj.eOld;
     eNew = eOld;
   }
   if( (u.cj.eNew!=u.cj.eOld)
    && (u.cj.eOld==PAGER_JOURNALMODE_WAL || u.cj.eNew==PAGER_JOURNALMODE_WAL)
   if( (eNew!=eOld)
    && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL)
   ){
     if( !db->autoCommit || db->nVdbeRead>1 ){
       rc = SQLITE_ERROR;
       sqlite3SetString(&p->zErrMsg, db,
       sqlite3SetString(&p->zErrMsg, db,
           "cannot change %s wal mode from within a transaction",
           (u.cj.eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
           (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
       );
       break;
     }else{
       if( u.cj.eOld==PAGER_JOURNALMODE_WAL ){
       if( eOld==PAGER_JOURNALMODE_WAL ){
         /* If leaving WAL mode, close the log file. If successful, the call
         ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
         ** file. An EXCLUSIVE lock may still be held on the database file
         ** after a successful return.
         ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
         ** file. An EXCLUSIVE lock may still be held on the database file
         ** after a successful return.
         */
         rc = sqlite3PagerCloseWal(u.cj.pPager);
         rc = sqlite3PagerCloseWal(pPager);
         if( rc==SQLITE_OK ){
           sqlite3PagerSetJournalMode(u.cj.pPager, u.cj.eNew);
           sqlite3PagerSetJournalMode(pPager, eNew);
         }
       }else if( u.cj.eOld==PAGER_JOURNALMODE_MEMORY ){
       }else if( eOld==PAGER_JOURNALMODE_MEMORY ){
         /* Cannot transition directly from MEMORY to WAL.  Use mode OFF
         ** as an intermediate */
         sqlite3PagerSetJournalMode(u.cj.pPager, PAGER_JOURNALMODE_OFF);
         sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF);
       }
       /* Open a transaction on the database file. Regardless of the journal
       ** mode, this transaction always uses a rollback journal.
       */
       assert( sqlite3BtreeIsInTrans(u.cj.pBt)==0 );
       assert( sqlite3BtreeIsInTrans(pBt)==0 );
       if( rc==SQLITE_OK ){
         rc = sqlite3BtreeSetVersion(u.cj.pBt, (u.cj.eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
         rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
       }
     }
   }
 #endif /* ifndef SQLITE_OMIT_WAL */
   if( rc ){
     u.cj.eNew = u.cj.eOld;
     eNew = eOld;
   }
   u.cj.eNew = sqlite3PagerSetJournalMode(u.cj.pPager, u.cj.eNew);
   eNew = sqlite3PagerSetJournalMode(pPager, eNew);
   pOut = &aMem[pOp->p2];
   pOut->flags = MEM_Str|MEM_Static|MEM_Term;
   pOut->z = (char *)sqlite3JournalModename(u.cj.eNew);
   pOut->z = (char *)sqlite3JournalModename(eNew);
   pOut->n = sqlite3Strlen30(pOut->z);
   pOut->enc = SQLITE_UTF8;
   sqlite3VdbeChangeEncoding(pOut, encoding);

@@ -71912,15 +72818,14 @@ case OP_Vacuum: {

 ** P2. Otherwise, fall through to the next instruction.
 */
 case OP_IncrVacuum: {        /* jump */
 #if 0  /* local variables moved into u.ck */
   Btree *pBt;
 #endif /* local variables moved into u.ck */
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
   assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
   assert( p->readOnly==0 );
   u.ck.pBt = db->aDb[pOp->p1].pBt;
   rc = sqlite3BtreeIncrVacuum(u.ck.pBt);
   pBt = db->aDb[pOp->p1].pBt;
   rc = sqlite3BtreeIncrVacuum(pBt);
   VdbeBranchTaken(rc==SQLITE_DONE,2);
   if( rc==SQLITE_DONE ){
     pc = pOp->p2 - 1;
     rc = SQLITE_OK;

@@ -71949,6 +72854,7 @@ case OP_Expire: {

 #ifndef SQLITE_OMIT_SHARED_CACHE
 /* Opcode: TableLock P1 P2 P3 P4 *
 ** Synopsis: iDb=P1 root=P2 write=P3
 **
 ** Obtain a lock on a particular table. This instruction is only used when
 ** the shared-cache feature is enabled.

@@ -71990,12 +72896,10 @@ case OP_TableLock: {

 ** code will be set to SQLITE_LOCKED.
 */
 case OP_VBegin: {
 #if 0  /* local variables moved into u.cl */
   VTable *pVTab;
 #endif /* local variables moved into u.cl */
   u.cl.pVTab = pOp->p4.pVtab;
   rc = sqlite3VtabBegin(db, u.cl.pVTab);
   if( u.cl.pVTab ) sqlite3VtabImportErrmsg(p, u.cl.pVTab->pVtab);
   pVTab = pOp->p4.pVtab;
   rc = sqlite3VtabBegin(db, pVTab);
   if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab);
   break;
 }
 #endif /* SQLITE_OMIT_VIRTUALTABLE */

@@ -72034,33 +72938,30 @@ case OP_VDestroy: {

 ** table and stores that cursor in P1.
 */
 case OP_VOpen: {
 #if 0  /* local variables moved into u.cm */
   VdbeCursor *pCur;
   sqlite3_vtab_cursor *pVtabCursor;
   sqlite3_vtab *pVtab;
   sqlite3_module *pModule;
 #endif /* local variables moved into u.cm */
   assert( p->bIsReader );
   u.cm.pCur = 0;
   u.cm.pVtabCursor = 0;
   u.cm.pVtab = pOp->p4.pVtab->pVtab;
   u.cm.pModule = (sqlite3_module *)u.cm.pVtab->pModule;
   assert(u.cm.pVtab && u.cm.pModule);
   rc = u.cm.pModule->xOpen(u.cm.pVtab, &u.cm.pVtabCursor);
   sqlite3VtabImportErrmsg(p, u.cm.pVtab);
   pCur = 0;
   pVtabCursor = 0;
   pVtab = pOp->p4.pVtab->pVtab;
   pModule = (sqlite3_module *)pVtab->pModule;
   assert(pVtab && pModule);
   rc = pModule->xOpen(pVtab, &pVtabCursor);
   sqlite3VtabImportErrmsg(p, pVtab);
   if( SQLITE_OK==rc ){
     /* Initialize sqlite3_vtab_cursor base class */
     u.cm.pVtabCursor->pVtab = u.cm.pVtab;
     pVtabCursor->pVtab = pVtab;
     /* Initialize vdbe cursor object */
     u.cm.pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
     if( u.cm.pCur ){
       u.cm.pCur->pVtabCursor = u.cm.pVtabCursor;
       u.cm.pCur->pModule = u.cm.pVtabCursor->pVtab->pModule;
     pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
     if( pCur ){
       pCur->pVtabCursor = pVtabCursor;
     }else{
       db->mallocFailed = 1;
       u.cm.pModule->xClose(u.cm.pVtabCursor);
       pModule->xClose(pVtabCursor);
     }
   }
   break;

@@ -72069,6 +72970,7 @@ case OP_VOpen: {

 #ifndef SQLITE_OMIT_VIRTUALTABLE
 /* Opcode: VFilter P1 P2 P3 P4 *
 ** Synopsis: iPlan=r[P3] zPlan='P4'
 **
 ** P1 is a cursor opened using VOpen.  P2 is an address to jump to if
 ** the filtered result set is empty.

@@ -72087,7 +72989,6 @@ case OP_VOpen: {

 ** A jump is made to P2 if the result set after filtering would be empty.
 */
 case OP_VFilter: {   /* jump */
 #if 0  /* local variables moved into u.cn */
   int nArg;
   int iQuery;
   const sqlite3_module *pModule;

@@ -72099,45 +73000,43 @@ case OP_VFilter: { /* jump */

   int res;
   int i;
   Mem **apArg;
 #endif /* local variables moved into u.cn */
   u.cn.pQuery = &aMem[pOp->p3];
   u.cn.pArgc = &u.cn.pQuery[1];
   u.cn.pCur = p->apCsr[pOp->p1];
   assert( memIsValid(u.cn.pQuery) );
   REGISTER_TRACE(pOp->p3, u.cn.pQuery);
   assert( u.cn.pCur->pVtabCursor );
   u.cn.pVtabCursor = u.cn.pCur->pVtabCursor;
   u.cn.pVtab = u.cn.pVtabCursor->pVtab;
   u.cn.pModule = u.cn.pVtab->pModule;
   pQuery = &aMem[pOp->p3];
   pArgc = &pQuery[1];
   pCur = p->apCsr[pOp->p1];
   assert( memIsValid(pQuery) );
   REGISTER_TRACE(pOp->p3, pQuery);
   assert( pCur->pVtabCursor );
   pVtabCursor = pCur->pVtabCursor;
   pVtab = pVtabCursor->pVtab;
   pModule = pVtab->pModule;
   /* Grab the index number and argc parameters */
   assert( (u.cn.pQuery->flags&MEM_Int)!=0 && u.cn.pArgc->flags==MEM_Int );
   u.cn.nArg = (int)u.cn.pArgc->u.i;
   u.cn.iQuery = (int)u.cn.pQuery->u.i;
   assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
   nArg = (int)pArgc->u.i;
   iQuery = (int)pQuery->u.i;
   /* Invoke the xFilter method */
   {
     u.cn.res = 0;
     u.cn.apArg = p->apArg;
     for(u.cn.i = 0; u.cn.i<u.cn.nArg; u.cn.i++){
       u.cn.apArg[u.cn.i] = &u.cn.pArgc[u.cn.i+1];
       sqlite3VdbeMemStoreType(u.cn.apArg[u.cn.i]);
     res = 0;
     apArg = p->apArg;
     for(i = 0; i<nArg; i++){
       apArg[i] = &pArgc[i+1];
     }
     p->inVtabMethod = 1;
     rc = u.cn.pModule->xFilter(u.cn.pVtabCursor, u.cn.iQuery, pOp->p4.z, u.cn.nArg, u.cn.apArg);
     rc = pModule->xFilter(pVtabCursor, iQuery, pOp->p4.z, nArg, apArg);
     p->inVtabMethod = 0;
     sqlite3VtabImportErrmsg(p, u.cn.pVtab);
     sqlite3VtabImportErrmsg(p, pVtab);
     if( rc==SQLITE_OK ){
       u.cn.res = u.cn.pModule->xEof(u.cn.pVtabCursor);
       res = pModule->xEof(pVtabCursor);
     }
     if( u.cn.res ){
     VdbeBranchTaken(res!=0,2);
     if( res ){
       pc = pOp->p2 - 1;
     }
   }
   u.cn.pCur->nullRow = 0;
   pCur->nullRow = 0;
   break;
 }

@@ -72145,57 +73044,56 @@ case OP_VFilter: { /* jump */

 #ifndef SQLITE_OMIT_VIRTUALTABLE
 /* Opcode: VColumn P1 P2 P3 * *
 ** Synopsis: r[P3]=vcolumn(P2)
 **
 ** Store the value of the P2-th column of
 ** the row of the virtual-table that the
 ** P1 cursor is pointing to into register P3.
 */
 case OP_VColumn: {
 #if 0  /* local variables moved into u.co */
   sqlite3_vtab *pVtab;
   const sqlite3_module *pModule;
   Mem *pDest;
   sqlite3_context sContext;
 #endif /* local variables moved into u.co */
   VdbeCursor *pCur = p->apCsr[pOp->p1];
   assert( pCur->pVtabCursor );
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   u.co.pDest = &aMem[pOp->p3];
   memAboutToChange(p, u.co.pDest);
   pDest = &aMem[pOp->p3];
   memAboutToChange(p, pDest);
   if( pCur->nullRow ){
     sqlite3VdbeMemSetNull(u.co.pDest);
     sqlite3VdbeMemSetNull(pDest);
     break;
   }
   u.co.pVtab = pCur->pVtabCursor->pVtab;
   u.co.pModule = u.co.pVtab->pModule;
   assert( u.co.pModule->xColumn );
   memset(&u.co.sContext, 0, sizeof(u.co.sContext));
   pVtab = pCur->pVtabCursor->pVtab;
   pModule = pVtab->pModule;
   assert( pModule->xColumn );
   memset(&sContext, 0, sizeof(sContext));
   /* The output cell may already have a buffer allocated. Move
   ** the current contents to u.co.sContext.s so in case the user-function
   ** can use the already allocated buffer instead of allocating a
   ** the current contents to sContext.s so in case the user-function
   ** can use the already allocated buffer instead of allocating a
   ** new one.
   */
   sqlite3VdbeMemMove(&u.co.sContext.s, u.co.pDest);
   MemSetTypeFlag(&u.co.sContext.s, MEM_Null);
   sqlite3VdbeMemMove(&sContext.s, pDest);
   MemSetTypeFlag(&sContext.s, MEM_Null);
   rc = u.co.pModule->xColumn(pCur->pVtabCursor, &u.co.sContext, pOp->p2);
   sqlite3VtabImportErrmsg(p, u.co.pVtab);
   if( u.co.sContext.isError ){
     rc = u.co.sContext.isError;
   rc = pModule->xColumn(pCur->pVtabCursor, &sContext, pOp->p2);
   sqlite3VtabImportErrmsg(p, pVtab);
   if( sContext.isError ){
     rc = sContext.isError;
   }
   /* Copy the result of the function to the P3 register. We
   ** do this regardless of whether or not an error occurred to ensure any
   ** dynamic allocation in u.co.sContext.s (a Mem struct) is  released.
   ** dynamic allocation in sContext.s (a Mem struct) is  released.
   */
   sqlite3VdbeChangeEncoding(&u.co.sContext.s, encoding);
   sqlite3VdbeMemMove(u.co.pDest, &u.co.sContext.s);
   REGISTER_TRACE(pOp->p3, u.co.pDest);
   UPDATE_MAX_BLOBSIZE(u.co.pDest);
   sqlite3VdbeChangeEncoding(&sContext.s, encoding);
   sqlite3VdbeMemMove(pDest, &sContext.s);
   REGISTER_TRACE(pOp->p3, pDest);
   UPDATE_MAX_BLOBSIZE(pDest);
   if( sqlite3VdbeMemTooBig(u.co.pDest) ){
   if( sqlite3VdbeMemTooBig(pDest) ){
     goto too_big;
   }
   break;

@@ -72210,38 +73108,36 @@ case OP_VColumn: {

 ** the end of its result set, then fall through to the next instruction.
 */
 case OP_VNext: {   /* jump */
 #if 0  /* local variables moved into u.cp */
   sqlite3_vtab *pVtab;
   const sqlite3_module *pModule;
   int res;
   VdbeCursor *pCur;
 #endif /* local variables moved into u.cp */
   u.cp.res = 0;
   u.cp.pCur = p->apCsr[pOp->p1];
   assert( u.cp.pCur->pVtabCursor );
   if( u.cp.pCur->nullRow ){
   res = 0;
   pCur = p->apCsr[pOp->p1];
   assert( pCur->pVtabCursor );
   if( pCur->nullRow ){
     break;
   }
   u.cp.pVtab = u.cp.pCur->pVtabCursor->pVtab;
   u.cp.pModule = u.cp.pVtab->pModule;
   assert( u.cp.pModule->xNext );
   pVtab = pCur->pVtabCursor->pVtab;
   pModule = pVtab->pModule;
   assert( pModule->xNext );
   /* Invoke the xNext() method of the module. There is no way for the
   ** underlying implementation to return an error if one occurs during
   ** xNext(). Instead, if an error occurs, true is returned (indicating that
   ** xNext(). Instead, if an error occurs, true is returned (indicating that
   ** data is available) and the error code returned when xColumn or
   ** some other method is next invoked on the save virtual table cursor.
   */
   p->inVtabMethod = 1;
   rc = u.cp.pModule->xNext(u.cp.pCur->pVtabCursor);
   rc = pModule->xNext(pCur->pVtabCursor);
   p->inVtabMethod = 0;
   sqlite3VtabImportErrmsg(p, u.cp.pVtab);
   sqlite3VtabImportErrmsg(p, pVtab);
   if( rc==SQLITE_OK ){
     u.cp.res = u.cp.pModule->xEof(u.cp.pCur->pVtabCursor);
     res = pModule->xEof(pCur->pVtabCursor);
   }
   if( !u.cp.res ){
   VdbeBranchTaken(!res,2);
   if( !res ){
     /* If there is data, jump to P2 */
     pc = pOp->p2 - 1;
   }

@@ -72257,25 +73153,23 @@ case OP_VNext: { /* jump */

 ** in register P1 is passed as the zName argument to the xRename method.
 */
 case OP_VRename: {
 #if 0  /* local variables moved into u.cq */
   sqlite3_vtab *pVtab;
   Mem *pName;
 #endif /* local variables moved into u.cq */
   u.cq.pVtab = pOp->p4.pVtab->pVtab;
   u.cq.pName = &aMem[pOp->p1];
   assert( u.cq.pVtab->pModule->xRename );
   assert( memIsValid(u.cq.pName) );
   pVtab = pOp->p4.pVtab->pVtab;
   pName = &aMem[pOp->p1];
   assert( pVtab->pModule->xRename );
   assert( memIsValid(pName) );
   assert( p->readOnly==0 );
   REGISTER_TRACE(pOp->p1, u.cq.pName);
   assert( u.cq.pName->flags & MEM_Str );
   testcase( u.cq.pName->enc==SQLITE_UTF8 );
   testcase( u.cq.pName->enc==SQLITE_UTF16BE );
   testcase( u.cq.pName->enc==SQLITE_UTF16LE );
   rc = sqlite3VdbeChangeEncoding(u.cq.pName, SQLITE_UTF8);
   REGISTER_TRACE(pOp->p1, pName);
   assert( pName->flags & MEM_Str );
   testcase( pName->enc==SQLITE_UTF8 );
   testcase( pName->enc==SQLITE_UTF16BE );
   testcase( pName->enc==SQLITE_UTF16LE );
   rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8);
   if( rc==SQLITE_OK ){
     rc = u.cq.pVtab->pModule->xRename(u.cq.pVtab, u.cq.pName->z);
     sqlite3VtabImportErrmsg(p, u.cq.pVtab);
     rc = pVtab->pModule->xRename(pVtab, pName->z);
     sqlite3VtabImportErrmsg(p, pVtab);
     p->expired = 0;
   }
   break;

@@ -72283,7 +73177,8 @@ case OP_VRename: {

 #endif
 #ifndef SQLITE_OMIT_VIRTUALTABLE
 /* Opcode: VUpdate P1 P2 P3 P4 *
 /* Opcode: VUpdate P1 P2 P3 P4 P5
 ** Synopsis: data=r[P3@P2]
 **
 ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
 ** This opcode invokes the corresponding xUpdate method. P2 values

@@ -72305,9 +73200,11 @@ case OP_VRename: {

 ** P1 is a boolean flag. If it is set to true and the xUpdate call
 ** is successful, then the value returned by sqlite3_last_insert_rowid()
 ** is set to the value of the rowid for the row just inserted.
 **
 ** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to
 ** apply in the case of a constraint failure on an insert or update.
 */
 case OP_VUpdate: {
 #if 0  /* local variables moved into u.cr */
   sqlite3_vtab *pVtab;
   sqlite3_module *pModule;
   int nArg;

@@ -72315,34 +73212,32 @@ case OP_VUpdate: {

   sqlite_int64 rowid;
   Mem **apArg;
   Mem *pX;
 #endif /* local variables moved into u.cr */
   assert( pOp->p2==1        || pOp->p5==OE_Fail   || pOp->p5==OE_Rollback
   assert( pOp->p2==1        || pOp->p5==OE_Fail   || pOp->p5==OE_Rollback
        || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
   );
   assert( p->readOnly==0 );
   u.cr.pVtab = pOp->p4.pVtab->pVtab;
   u.cr.pModule = (sqlite3_module *)u.cr.pVtab->pModule;
   u.cr.nArg = pOp->p2;
   pVtab = pOp->p4.pVtab->pVtab;
   pModule = (sqlite3_module *)pVtab->pModule;
   nArg = pOp->p2;
   assert( pOp->p4type==P4_VTAB );
   if( ALWAYS(u.cr.pModule->xUpdate) ){
   if( ALWAYS(pModule->xUpdate) ){
     u8 vtabOnConflict = db->vtabOnConflict;
     u.cr.apArg = p->apArg;
     u.cr.pX = &aMem[pOp->p3];
     for(u.cr.i=0; u.cr.i<u.cr.nArg; u.cr.i++){
       assert( memIsValid(u.cr.pX) );
       memAboutToChange(p, u.cr.pX);
       sqlite3VdbeMemStoreType(u.cr.pX);
       u.cr.apArg[u.cr.i] = u.cr.pX;
       u.cr.pX++;
     apArg = p->apArg;
     pX = &aMem[pOp->p3];
     for(i=0; i<nArg; i++){
       assert( memIsValid(pX) );
       memAboutToChange(p, pX);
       apArg[i] = pX;
       pX++;
     }
     db->vtabOnConflict = pOp->p5;
     rc = u.cr.pModule->xUpdate(u.cr.pVtab, u.cr.nArg, u.cr.apArg, &u.cr.rowid);
     rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
     db->vtabOnConflict = vtabOnConflict;
     sqlite3VtabImportErrmsg(p, u.cr.pVtab);
     sqlite3VtabImportErrmsg(p, pVtab);
     if( rc==SQLITE_OK && pOp->p1 ){
       assert( u.cr.nArg>1 && u.cr.apArg[0] && (u.cr.apArg[0]->flags&MEM_Null) );
       db->lastRowid = lastRowid = u.cr.rowid;
       assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
       db->lastRowid = lastRowid = rowid;
     }
     if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
       if( pOp->p5==OE_Ignore ){

@@ -72395,36 +73290,54 @@ case OP_MaxPgcnt: { /* out2-prerelease */

 #endif
 #ifndef SQLITE_OMIT_TRACE
 /* Opcode: Trace * * * P4 *
 /* Opcode: Init * P2 * P4 *
 ** Synopsis:  Start at P2
 **
 ** Programs contain a single instance of this opcode as the very first
 ** opcode.
 **
 ** If tracing is enabled (by the sqlite3_trace()) interface, then
 ** the UTF-8 string contained in P4 is emitted on the trace callback.
 ** Or if P4 is blank, use the string returned by sqlite3_sql().
 **
 ** If P2 is not zero, jump to instruction P2.
 */
 case OP_Trace: {
 #if 0  /* local variables moved into u.cs */
 case OP_Init: {          /* jump */
   char *zTrace;
   char *z;
 #endif /* local variables moved into u.cs */
   if( pOp->p2 ){
     pc = pOp->p2 - 1;
   }
 #ifndef SQLITE_OMIT_TRACE
   if( db->xTrace
    && !p->doingRerun
    && (u.cs.zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
    && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
   ){
     u.cs.z = sqlite3VdbeExpandSql(p, u.cs.zTrace);
     db->xTrace(db->pTraceArg, u.cs.z);
     sqlite3DbFree(db, u.cs.z);
     z = sqlite3VdbeExpandSql(p, zTrace);
     db->xTrace(db->pTraceArg, z);
     sqlite3DbFree(db, z);
   }
 #ifdef SQLITE_USE_FCNTL_TRACE
   zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql);
   if( zTrace ){
     int i;
     for(i=0; i<db->nDb; i++){
       if( MASKBIT(i) & p->btreeMask)==0 ) continue;
       sqlite3_file_control(db, db->aDb[i].zName, SQLITE_FCNTL_TRACE, zTrace);
     }
   }
 #endif /* SQLITE_USE_FCNTL_TRACE */
 #ifdef SQLITE_DEBUG
   if( (db->flags & SQLITE_SqlTrace)!=0
    && (u.cs.zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
    && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
   ){
     sqlite3DebugPrintf("SQL-trace: %s\n", u.cs.zTrace);
     sqlite3DebugPrintf("SQL-trace: %s\n", zTrace);
   }
 #endif /* SQLITE_DEBUG */
 #endif /* SQLITE_OMIT_TRACE */
   break;
 }
 #endif
 /* Opcode: Noop * * * * *

@@ -72456,10 +73369,6 @@ default: { /* This is really OP_Noop and OP_Explain */

       u64 elapsed = sqlite3Hwtime() - start;
       pOp->cycles += elapsed;
       pOp->cnt++;
 #if 0
         fprintf(stdout, "%10llu ", elapsed);
         sqlite3VdbePrintOp(stdout, origPc, &aOp[origPc]);
 #endif
     }
 #endif

@@ -72472,13 +73381,13 @@ default: { /* This is really OP_Noop and OP_Explain */

     assert( pc>=-1 && pc<p->nOp );
 #ifdef SQLITE_DEBUG
     if( p->trace ){
       if( rc!=0 ) fprintf(p->trace,"rc=%d\n",rc);
     if( db->flags & SQLITE_VdbeTrace ){
       if( rc!=0 ) printf("rc=%d\n",rc);
       if( pOp->opflags & (OPFLG_OUT2_PRERELEASE|OPFLG_OUT2) ){
         registerTrace(p->trace, pOp->p2, &aMem[pOp->p2]);
         registerTrace(pOp->p2, &aMem[pOp->p2]);
       }
       if( pOp->opflags & OPFLG_OUT3 ){
         registerTrace(p->trace, pOp->p3, &aMem[pOp->p3]);
         registerTrace(pOp->p3, &aMem[pOp->p3]);
       }
     }
 #endif  /* SQLITE_DEBUG */

@@ -72549,6 +73458,7 @@ abort_due_to_interrupt:

   goto vdbe_error_halt;
 }
 /************** End of vdbe.c ************************************************/
 /************** Begin file vdbeblob.c ****************************************/
 /*

@@ -72615,7 +73525,8 @@ static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){

   rc = sqlite3_step(p->pStmt);
   if( rc==SQLITE_ROW ){
     u32 type = v->apCsr[0]->aType[p->iCol];
     VdbeCursor *pC = v->apCsr[0];
     u32 type = pC->aType[p->iCol];
     if( type<12 ){
       zErr = sqlite3MPrintf(p->db, "cannot open value of type %s",
           type==0?"null": type==7?"real": "integer"

@@ -72624,9 +73535,9 @@ static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){

       sqlite3_finalize(p->pStmt);
       p->pStmt = 0;
     }else{
       p->iOffset = v->apCsr[0]->aOffset[p->iCol];
       p->iOffset = pC->aType[p->iCol + pC->nField];
       p->nByte = sqlite3VdbeSerialTypeLen(type);
       p->pCsr =  v->apCsr[0]->pCursor;
       p->pCsr =  pC->pCursor;
       sqlite3BtreeEnterCursor(p->pCsr);
       sqlite3BtreeCacheOverflow(p->pCsr);
       sqlite3BtreeLeaveCursor(p->pCsr);

@@ -72683,22 +73594,20 @@ SQLITE_API int sqlite3_blob_open(

   ** which closes the b-tree cursor and (possibly) commits the
   ** transaction.
   */
   static const int iLn = VDBE_OFFSET_LINENO(4);
   static const VdbeOpList openBlob[] = {
     {OP_Transaction, 0, 0, 0},     /* 0: Start a transaction */
     {OP_VerifyCookie, 0, 0, 0},    /* 1: Check the schema cookie */
     {OP_TableLock, 0, 0, 0},       /* 2: Acquire a read or write lock */
     /* {OP_Transaction, 0, 0, 0},  // 0: Inserted separately */
     {OP_TableLock, 0, 0, 0},       /* 1: Acquire a read or write lock */
     /* One of the following two instructions is replaced by an OP_Noop. */
     {OP_OpenRead, 0, 0, 0},        /* 3: Open cursor 0 for reading */
     {OP_OpenWrite, 0, 0, 0},       /* 4: Open cursor 0 for read/write */
     {OP_Variable, 1, 1, 1},        /* 5: Push the rowid to the stack */
     {OP_NotExists, 0, 10, 1},      /* 6: Seek the cursor */
     {OP_Column, 0, 0, 1},          /* 7  */
     {OP_ResultRow, 1, 0, 0},       /* 8  */
     {OP_Goto, 0, 5, 0},            /* 9  */
     {OP_Close, 0, 0, 0},           /* 10 */
     {OP_Halt, 0, 0, 0},            /* 11 */
     {OP_OpenRead, 0, 0, 0},        /* 2: Open cursor 0 for reading */
     {OP_OpenWrite, 0, 0, 0},       /* 3: Open cursor 0 for read/write */
     {OP_Variable, 1, 1, 1},        /* 4: Push the rowid to the stack */
     {OP_NotExists, 0, 10, 1},      /* 5: Seek the cursor */
     {OP_Column, 0, 0, 1},          /* 6  */
     {OP_ResultRow, 1, 0, 0},       /* 7  */
     {OP_Goto, 0, 4, 0},            /* 8  */
     {OP_Close, 0, 0, 0},           /* 9  */
     {OP_Halt, 0, 0, 0},            /* 10 */
   };
   int rc = SQLITE_OK;

@@ -72729,6 +73638,10 @@ SQLITE_API int sqlite3_blob_open(

       pTab = 0;
       sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
     }
     if( pTab && !HasRowid(pTab) ){
       pTab = 0;
       sqlite3ErrorMsg(pParse, "cannot open table without rowid: %s", zTable);
     }
 #ifndef SQLITE_OMIT_VIEW
     if( pTab && pTab->pSelect ){
       pTab = 0;

@@ -72786,7 +73699,7 @@ SQLITE_API int sqlite3_blob_open(

 #endif
       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
         int j;
         for(j=0; j<pIdx->nColumn; j++){
         for(j=0; j<pIdx->nKeyCol; j++){
           if( pIdx->aiColumn[j]==iCol ){
             zFault = "indexed";
           }

@@ -72801,42 +73714,37 @@ SQLITE_API int sqlite3_blob_open(

       }
     }
     pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(db);
     pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(pParse);
     assert( pBlob->pStmt || db->mallocFailed );
     if( pBlob->pStmt ){
       Vdbe *v = (Vdbe *)pBlob->pStmt;
       int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
       sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
       /* Configure the OP_Transaction */
       sqlite3VdbeChangeP1(v, 0, iDb);
       sqlite3VdbeChangeP2(v, 0, flags);
       /* Configure the OP_VerifyCookie */
       sqlite3VdbeChangeP1(v, 1, iDb);
       sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
       sqlite3VdbeChangeP3(v, 1, pTab->pSchema->iGeneration);
       sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, flags,
                            pTab->pSchema->schema_cookie,
                            pTab->pSchema->iGeneration);
       sqlite3VdbeChangeP5(v, 1);
       sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
       /* Make sure a mutex is held on the table to be accessed */
       sqlite3VdbeUsesBtree(v, iDb);
       /* Configure the OP_TableLock instruction */
 #ifdef SQLITE_OMIT_SHARED_CACHE
       sqlite3VdbeChangeToNoop(v, 2);
       sqlite3VdbeChangeToNoop(v, 1);
 #else
       sqlite3VdbeChangeP1(v, 2, iDb);
       sqlite3VdbeChangeP2(v, 2, pTab->tnum);
       sqlite3VdbeChangeP3(v, 2, flags);
       sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
       sqlite3VdbeChangeP1(v, 1, iDb);
       sqlite3VdbeChangeP2(v, 1, pTab->tnum);
       sqlite3VdbeChangeP3(v, 1, flags);
       sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
 #endif
       /* Remove either the OP_OpenWrite or OpenRead. Set the P2
       ** parameter of the other to pTab->tnum.  */
       sqlite3VdbeChangeToNoop(v, 4 - flags);
       sqlite3VdbeChangeP2(v, 3 + flags, pTab->tnum);
       sqlite3VdbeChangeP3(v, 3 + flags, iDb);
       sqlite3VdbeChangeToNoop(v, 3 - flags);
       sqlite3VdbeChangeP2(v, 2 + flags, pTab->tnum);
       sqlite3VdbeChangeP3(v, 2 + flags, iDb);
       /* Configure the number of columns. Configure the cursor to
       ** think that the table has one more column than it really

@@ -72845,8 +73753,8 @@ SQLITE_API int sqlite3_blob_open(

       ** we can invoke OP_Column to fill in the vdbe cursors type
       ** and offset cache without causing any IO.
       */
       sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
       sqlite3VdbeChangeP2(v, 7, pTab->nCol);
       sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
       sqlite3VdbeChangeP2(v, 6, pTab->nCol);
       if( !db->mallocFailed ){
         pParse->nVar = 1;
         pParse->nMem = 1;

@@ -72875,6 +73783,7 @@ blob_open_out:

   }
   sqlite3Error(db, rc, (zErr ? "%s" : 0), zErr);
   sqlite3DbFree(db, zErr);
   sqlite3ParserReset(pParse);
   sqlite3StackFree(db, pParse);
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);

@@ -73407,7 +74316,7 @@ static int vdbeSorterIterInit(

 */
 static void vdbeSorterCompare(
   const VdbeCursor *pCsr,         /* Cursor object (for pKeyInfo) */
   int bOmitRowid,                 /* Ignore rowid field at end of keys */
   int nIgnore,                    /* Ignore the last nIgnore fields */
   const void *pKey1, int nKey1,   /* Left side of comparison */
   const void *pKey2, int nKey2,   /* Right side of comparison */
   int *pRes                       /* OUT: Result of comparison */

@@ -73421,8 +74330,8 @@ static void vdbeSorterCompare(

     sqlite3VdbeRecordUnpack(pKeyInfo, nKey2, pKey2, r2);
   }
   if( bOmitRowid ){
     r2->nField = pKeyInfo->nField;
   if( nIgnore ){
     r2->nField = pKeyInfo->nField - nIgnore;
     assert( r2->nField>0 );
     for(i=0; i<r2->nField; i++){
       if( r2->aMem[i].flags & MEM_Null ){

@@ -73430,10 +74339,10 @@ static void vdbeSorterCompare(

         return;
       }
     }
     r2->flags |= UNPACKED_PREFIX_MATCH;
     assert( r2->default_rc==0 );
   }
   *pRes = sqlite3VdbeRecordCompare(nKey1, pKey1, r2);
   *pRes = sqlite3VdbeRecordCompare(nKey1, pKey1, r2, 0);
 }
 /*

@@ -74048,13 +74957,14 @@ SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){

 SQLITE_PRIVATE int sqlite3VdbeSorterCompare(
   const VdbeCursor *pCsr,         /* Sorter cursor */
   Mem *pVal,                      /* Value to compare to current sorter key */
   int nIgnore,                    /* Ignore this many fields at the end */
   int *pRes                       /* OUT: Result of comparison */
 ){
   VdbeSorter *pSorter = pCsr->pSorter;
   void *pKey; int nKey;           /* Sorter key to compare pVal with */
   pKey = vdbeSorterRowkey(pSorter, &nKey);
   vdbeSorterCompare(pCsr, 1, pVal->z, pVal->n, pKey, nKey, pRes);
   vdbeSorterCompare(pCsr, nIgnore, pVal->z, pVal->n, pKey, nKey, pRes);
   return SQLITE_OK;
 }

@@ -74689,9 +75599,12 @@ SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){

 /*
 ** Call sqlite3WalkExpr() for every expression in Select statement p.
 ** Invoke sqlite3WalkSelect() for subqueries in the FROM clause and
 ** on the compound select chain, p->pPrior.  Invoke the xSelectCallback()
 ** either before or after the walk of expressions and FROM clause, depending
 ** on whether pWalker->bSelectDepthFirst is false or true, respectively.
 ** on the compound select chain, p->pPrior.
 **
 ** If it is not NULL, the xSelectCallback() callback is invoked before
 ** the walk of the expressions and FROM clause. The xSelectCallback2()
 ** method, if it is not NULL, is invoked following the walk of the
 ** expressions and FROM clause.
 **
 ** Return WRC_Continue under normal conditions.  Return WRC_Abort if
 ** there is an abort request.

@@ -74701,11 +75614,13 @@ SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){

 */
 SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){
   int rc;
   if( p==0 || pWalker->xSelectCallback==0 ) return WRC_Continue;
   if( p==0 || (pWalker->xSelectCallback==0 && pWalker->xSelectCallback2==0) ){
     return WRC_Continue;
   }
   rc = WRC_Continue;
   pWalker->walkerDepth++;
   while( p ){
     if( !pWalker->bSelectDepthFirst ){
     if( pWalker->xSelectCallback ){
        rc = pWalker->xSelectCallback(pWalker, p);
        if( rc ) break;
     }

@@ -74715,12 +75630,8 @@ SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){

       pWalker->walkerDepth--;
       return WRC_Abort;
     }
     if( pWalker->bSelectDepthFirst ){
       rc = pWalker->xSelectCallback(pWalker, p);
       /* Depth-first search is currently only used for
       ** selectAddSubqueryTypeInfo() and that routine always returns
       ** WRC_Continue (0).  So the following branch is never taken. */
       if( NEVER(rc) ) break;
     if( pWalker->xSelectCallback2 ){
       pWalker->xSelectCallback2(pWalker, p);
     }
     p = p->pPrior;
   }

@@ -74839,10 +75750,10 @@ static void resolveAlias(

     pDup = sqlite3PExpr(pParse, TK_AS, pDup, 0, 0);
     if( pDup==0 ) return;
     ExprSetProperty(pDup, EP_Skip);
     if( pEList->a[iCol].iAlias==0 ){
       pEList->a[iCol].iAlias = (u16)(++pParse->nAlias);
     if( pEList->a[iCol].u.x.iAlias==0 ){
       pEList->a[iCol].u.x.iAlias = (u16)(++pParse->nAlias);
     }
     pDup->iTable = pEList->a[iCol].iAlias;
     pDup->iTable = pEList->a[iCol].u.x.iAlias;
   }
   if( pExpr->op==TK_COLLATE ){
     pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);

@@ -74957,7 +75868,9 @@ static int lookupName(

   struct SrcList_item *pMatch = 0;  /* The matching pSrcList item */
   NameContext *pTopNC = pNC;        /* First namecontext in the list */
   Schema *pSchema = 0;              /* Schema of the expression */
   int isTrigger = 0;
   int isTrigger = 0;                /* True if resolved to a trigger column */
   Table *pTab = 0;                  /* Table hold the row */
   Column *pCol;                     /* A column of pTab */
   assert( pNC );     /* the name context cannot be NULL. */
   assert( zCol );    /* The Z in X.Y.Z cannot be NULL */

@@ -74998,9 +75911,6 @@ static int lookupName(

     if( pSrcList ){
       for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
         Table *pTab;
         Column *pCol;
         pTab = pItem->pTab;
         assert( pTab!=0 && pTab->zName!=0 );
         assert( pTab->nCol>0 );

@@ -75060,9 +75970,8 @@ static int lookupName(

     /* If we have not already resolved the name, then maybe
     ** it is a new.* or old.* trigger argument reference
     */
     if( zDb==0 && zTab!=0 && cnt==0 && pParse->pTriggerTab!=0 ){
     if( zDb==0 && zTab!=0 && cntTab==0 && pParse->pTriggerTab!=0 ){
       int op = pParse->eTriggerOp;
       Table *pTab = 0;
       assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
       if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){
         pExpr->iTable = 1;

@@ -75070,14 +75979,15 @@ static int lookupName(

       }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){
         pExpr->iTable = 0;
         pTab = pParse->pTriggerTab;
       }else{
         pTab = 0;
       }
       if( pTab ){
         int iCol;
         pSchema = pTab->pSchema;
         cntTab++;
         for(iCol=0; iCol<pTab->nCol; iCol++){
           Column *pCol = &pTab->aCol[iCol];
         for(iCol=0, pCol=pTab->aCol; iCol<pTab->nCol; iCol++, pCol++){
           if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
             if( iCol==pTab->iPKey ){
               iCol = -1;

@@ -75085,8 +75995,10 @@ static int lookupName(

             break;
           }
         }
         if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) ){
           iCol = -1;        /* IMP: R-44911-55124 */
         if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) && HasRowid(pTab) ){
           /* IMP: R-24309-18625 */
           /* IMP: R-44911-55124 */
           iCol = -1;
         }
         if( iCol<pTab->nCol ){
           cnt++;

@@ -75112,7 +76024,8 @@ static int lookupName(

     /*
     ** Perhaps the name is a reference to the ROWID
     */
     if( cnt==0 && cntTab==1 && sqlite3IsRowid(zCol) ){
     if( cnt==0 && cntTab==1 && pMatch && sqlite3IsRowid(zCol)
      && HasRowid(pMatch->pTab) ){
       cnt = 1;
       pExpr->iColumn = -1;     /* IMP: R-44911-55124 */
       pExpr->affinity = SQLITE_AFF_INTEGER;

@@ -75400,7 +76313,6 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){

     /* Resolve function names
     */
     case TK_CONST_FUNC:
     case TK_FUNCTION: {
       ExprList *pList = pExpr->x.pList;    /* The argument list */
       int n = pList ? pList->nExpr : 0;    /* Number of arguments */

@@ -75413,7 +76325,6 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){

       FuncDef *pDef;              /* Information about the function */
       u8 enc = ENC(pParse->db);   /* The database encoding */
       testcase( pExpr->op==TK_CONST_FUNC );
       assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
       notValidPartIdxWhere(pParse, pNC, "functions");
       zId = pExpr->u.zToken;

@@ -75458,6 +76369,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){

           pExpr->op = TK_NULL;
           return WRC_Prune;
         }
         if( pDef->funcFlags & SQLITE_FUNC_CONSTANT ) ExprSetProperty(pExpr,EP_Constant);
       }
 #endif
       if( is_agg && (pNC->ncFlags & NC_AllowAgg)==0 ){

@@ -75709,7 +76621,7 @@ static int resolveCompoundOrderBy(

           pItem->pExpr->pLeft = pNew;
         }
         sqlite3ExprDelete(db, pE);
         pItem->iOrderByCol = (u16)iCol;
         pItem->u.x.iOrderByCol = (u16)iCol;
         pItem->done = 1;
       }else{
         moreToDo = 1;

@@ -75730,8 +76642,8 @@ static int resolveCompoundOrderBy(

 /*
 ** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
 ** the SELECT statement pSelect.  If any term is reference to a
 ** result set expression (as determined by the ExprList.a.iOrderByCol field)
 ** then convert that term into a copy of the corresponding result set
 ** result set expression (as determined by the ExprList.a.u.x.iOrderByCol
 ** field) then convert that term into a copy of the corresponding result set
 ** column.
 **
 ** If any errors are detected, add an error message to pParse and

@@ -75758,12 +76670,12 @@ SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(

   pEList = pSelect->pEList;
   assert( pEList!=0 );  /* sqlite3SelectNew() guarantees this */
   for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
     if( pItem->iOrderByCol ){
       if( pItem->iOrderByCol>pEList->nExpr ){
     if( pItem->u.x.iOrderByCol ){
       if( pItem->u.x.iOrderByCol>pEList->nExpr ){
         resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
         return 1;
       }
       resolveAlias(pParse, pEList, pItem->iOrderByCol-1, pItem->pExpr, zType,0);
       resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr, zType,0);
     }
   }
   return 0;

@@ -75812,7 +76724,7 @@ static int resolveOrderGroupBy(

         ** a copy of the iCol-th result-set column.  The subsequent call to
         ** sqlite3ResolveOrderGroupBy() will convert the expression to a
         ** copy of the iCol-th result-set expression. */
         pItem->iOrderByCol = (u16)iCol;
         pItem->u.x.iOrderByCol = (u16)iCol;
         continue;
       }
     }

@@ -75824,18 +76736,18 @@ static int resolveOrderGroupBy(

         resolveOutOfRangeError(pParse, zType, i+1, nResult);
         return 1;
       }
       pItem->iOrderByCol = (u16)iCol;
       pItem->u.x.iOrderByCol = (u16)iCol;
       continue;
     }
     /* Otherwise, treat the ORDER BY term as an ordinary expression */
     pItem->iOrderByCol = 0;
     pItem->u.x.iOrderByCol = 0;
     if( sqlite3ResolveExprNames(pNC, pE) ){
       return 1;
     }
     for(j=0; j<pSelect->pEList->nExpr; j++){
       if( sqlite3ExprCompare(pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
         pItem->iOrderByCol = j+1;
         pItem->u.x.iOrderByCol = j+1;
       }
     }
   }

@@ -76707,16 +77619,25 @@ SQLITE_PRIVATE Expr *sqlite3PExpr(

 }
 /*
 ** Return 1 if an expression must be FALSE in all cases and 0 if the
 ** expression might be true.  This is an optimization.  If is OK to
 ** return 0 here even if the expression really is always false (a
 ** false negative).  But it is a bug to return 1 if the expression
 ** might be true in some rare circumstances (a false positive.)
 ** If the expression is always either TRUE or FALSE (respectively),
 ** then return 1.  If one cannot determine the truth value of the
 ** expression at compile-time return 0.
 **
 ** This is an optimization.  If is OK to return 0 here even if
 ** the expression really is always false or false (a false negative).
 ** But it is a bug to return 1 if the expression might have different
 ** boolean values in different circumstances (a false positive.)
 **
 ** Note that if the expression is part of conditional for a
 ** LEFT JOIN, then we cannot determine at compile-time whether or not
 ** is it true or false, so always return 0.
 */
 static int exprAlwaysTrue(Expr *p){
   int v = 0;
   if( ExprHasProperty(p, EP_FromJoin) ) return 0;
   if( !sqlite3ExprIsInteger(p, &v) ) return 0;
   return v!=0;
 }
 static int exprAlwaysFalse(Expr *p){
   int v = 0;
   if( ExprHasProperty(p, EP_FromJoin) ) return 0;

@@ -77071,6 +77992,33 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){

 }
 /*
 ** Create and return a deep copy of the object passed as the second
 ** argument. If an OOM condition is encountered, NULL is returned
 ** and the db->mallocFailed flag set.
 */
 #ifndef SQLITE_OMIT_CTE
 static With *withDup(sqlite3 *db, With *p){
   With *pRet = 0;
   if( p ){
     int nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1);
     pRet = sqlite3DbMallocZero(db, nByte);
     if( pRet ){
       int i;
       pRet->nCte = p->nCte;
       for(i=0; i<p->nCte; i++){
         pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0);
         pRet->a[i].pCols = sqlite3ExprListDup(db, p->a[i].pCols, 0);
         pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName);
       }
     }
   }
   return pRet;
 }
 #else
 # define withDup(x,y) 0
 #endif
 /*
 ** The following group of routines make deep copies of expressions,
 ** expression lists, ID lists, and select statements.  The copies can
 ** be deleted (by being passed to their respective ...Delete() routines)

@@ -77114,8 +78062,7 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags)

     pItem->sortOrder = pOldItem->sortOrder;
     pItem->done = 0;
     pItem->bSpanIsTab = pOldItem->bSpanIsTab;
     pItem->iOrderByCol = pOldItem->iOrderByCol;
     pItem->iAlias = pOldItem->iAlias;
     pItem->u = pOldItem->u;
   }
   return pNew;
 }

@@ -77151,6 +78098,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){

     pNewItem->regReturn = pOldItem->regReturn;
     pNewItem->isCorrelated = pOldItem->isCorrelated;
     pNewItem->viaCoroutine = pOldItem->viaCoroutine;
     pNewItem->isRecursive = pOldItem->isRecursive;
     pNewItem->zIndex = sqlite3DbStrDup(db, pOldItem->zIndex);
     pNewItem->notIndexed = pOldItem->notIndexed;
     pNewItem->pIndex = pOldItem->pIndex;

@@ -77208,10 +78156,11 @@ SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){

   pNew->iLimit = 0;
   pNew->iOffset = 0;
   pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
   pNew->pRightmost = 0;
   pNew->addrOpenEphm[0] = -1;
   pNew->addrOpenEphm[1] = -1;
   pNew->addrOpenEphm[2] = -1;
   pNew->nSelectRow = p->nSelectRow;
   pNew->pWith = withDup(db, p->pWith);
   return pNew;
 }
 #else

@@ -77376,9 +78325,12 @@ static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){

   switch( pExpr->op ){
     /* Consider functions to be constant if all their arguments are constant
     ** and pWalker->u.i==2 */
     ** and either pWalker->u.i==2 or the function as the SQLITE_FUNC_CONST
     ** flag. */
     case TK_FUNCTION:
       if( pWalker->u.i==2 ) return 0;
       if( pWalker->u.i==2 || ExprHasProperty(pExpr,EP_Constant) ){
         return WRC_Continue;
       }
       /* Fall through */
     case TK_ID:
     case TK_COLUMN:

@@ -77514,24 +78466,6 @@ SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){

 }
 /*
 ** Generate an OP_IsNull instruction that tests register iReg and jumps
 ** to location iDest if the value in iReg is NULL.  The value in iReg
 ** was computed by pExpr.  If we can look at pExpr at compile-time and
 ** determine that it can never generate a NULL, then the OP_IsNull operation
 ** can be omitted.
 */
 SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(
   Vdbe *v,            /* The VDBE under construction */
   const Expr *pExpr,  /* Only generate OP_IsNull if this expr can be NULL */
   int iReg,           /* Test the value in this register for NULL */
   int iDest           /* Jump here if the value is null */
 ){
   if( sqlite3ExprCanBeNull(pExpr) ){
     sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iDest);
   }
 }
 /*
 ** Return TRUE if the given expression is a constant which would be
 ** unchanged by OP_Affinity with the affinity given in the second
 ** argument.

@@ -77716,8 +78650,8 @@ SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){

     sqlite3 *db = pParse->db;              /* Database connection */
     Table *pTab;                           /* Table <table>. */
     Expr *pExpr;                           /* Expression <column> */
     int iCol;                              /* Index of column <column> */
     int iDb;                               /* Database idx for pTab */
     i16 iCol;                              /* Index of column <column> */
     i16 iDb;                               /* Database idx for pTab */
     assert( p );                        /* Because of isCandidateForInOpt(p) */
     assert( p->pEList!=0 );             /* Because of isCandidateForInOpt(p) */

@@ -77725,9 +78659,9 @@ SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){

     assert( p->pSrc!=0 );               /* Because of isCandidateForInOpt(p) */
     pTab = p->pSrc->a[0].pTab;
     pExpr = p->pEList->a[0].pExpr;
     iCol = pExpr->iColumn;
     iCol = (i16)pExpr->iColumn;
     /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
     /* Code an OP_Transaction and OP_TableLock for <table>. */
     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
     sqlite3CodeVerifySchema(pParse, iDb);
     sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);

@@ -77738,9 +78672,8 @@ SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){

     */
     assert(v);
     if( iCol<0 ){
       int iAddr;
       iAddr = sqlite3CodeOnce(pParse);
       int iAddr = sqlite3CodeOnce(pParse);
       VdbeCoverage(v);
       sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
       eType = IN_INDEX_ROWID;

@@ -77763,25 +78696,20 @@ SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){

       for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
         if( (pIdx->aiColumn[0]==iCol)
          && sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq
          && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
          && (!mustBeUnique || (pIdx->nKeyCol==1 && pIdx->onError!=OE_None))
         ){
           int iAddr;
           char *pKey;
           pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
           iAddr = sqlite3CodeOnce(pParse);
           sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
                                pKey,P4_KEYINFO_HANDOFF);
           int iAddr = sqlite3CodeOnce(pParse); VdbeCoverage(v);
           sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
           sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
           VdbeComment((v, "%s", pIdx->zName));
           assert( IN_INDEX_INDEX_DESC == IN_INDEX_INDEX_ASC+1 );
           eType = IN_INDEX_INDEX_ASC + pIdx->aSortOrder[0];
           sqlite3VdbeJumpHere(v, iAddr);
           if( prNotFound && !pTab->aCol[iCol].notNull ){
             *prNotFound = ++pParse->nMem;
             sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
           }
           sqlite3VdbeJumpHere(v, iAddr);
         }
       }
     }

@@ -77870,7 +78798,7 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(

   ** save the results, and reuse the same result on subsequent invocations.
   */
   if( !ExprHasProperty(pExpr, EP_VarSelect) ){
     testAddr = sqlite3CodeOnce(pParse);
     testAddr = sqlite3CodeOnce(pParse); VdbeCoverage(v);
   }
 #ifndef SQLITE_OMIT_EXPLAIN

@@ -77911,8 +78839,7 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(

       */
       pExpr->iTable = pParse->nTab++;
       addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
       if( rMayHaveNull==0 ) sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
       pKeyInfo = isRowid ? 0 : sqlite3KeyInfoAlloc(pParse->db, 1);
       pKeyInfo = isRowid ? 0 : sqlite3KeyInfoAlloc(pParse->db, 1, 1);
       if( ExprHasProperty(pExpr, EP_xIsSelect) ){
         /* Case 1:     expr IN (SELECT ...)

@@ -77930,13 +78857,14 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(

         pExpr->x.pSelect->iLimit = 0;
         testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
         if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
           sqlite3DbFree(pParse->db, pKeyInfo);
           sqlite3KeyInfoUnref(pKeyInfo);
           return 0;
         }
         pEList = pExpr->x.pSelect->pEList;
         assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
         assert( pEList!=0 );
         assert( pEList->nExpr>0 );
         assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
         pKeyInfo->aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
                                                          pEList->a[0].pExpr);
       }else if( ALWAYS(pExpr->x.pList!=0) ){

@@ -77956,6 +78884,7 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(

           affinity = SQLITE_AFF_NONE;
         }
         if( pKeyInfo ){
           assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
           pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
         }

@@ -77985,6 +78914,7 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(

             if( isRowid ){
               sqlite3VdbeAddOp2(v, OP_MustBeInt, r3,
                                 sqlite3VdbeCurrentAddr(v)+2);
               VdbeCoverage(v);
               sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
             }else{
               sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);

@@ -77997,7 +78927,7 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(

         sqlite3ReleaseTempReg(pParse, r2);
       }
       if( pKeyInfo ){
         sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO_HANDOFF);
         sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO);
       }
       break;
     }

@@ -78108,10 +79038,11 @@ static void sqlite3ExprCodeIN(

   if( destIfNull==destIfFalse ){
     /* Shortcut for the common case where the false and NULL outcomes are
     ** the same. */
     sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
     sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull); VdbeCoverage(v);
   }else{
     int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
     int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
     VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
     sqlite3VdbeJumpHere(v, addr1);
   }

@@ -78119,8 +79050,9 @@ static void sqlite3ExprCodeIN(

   if( eType==IN_INDEX_ROWID ){
     /* In this case, the RHS is the ROWID of table b-tree
     */
     sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
     sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse); VdbeCoverage(v);
     sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
     VdbeCoverage(v);
   }else{
     /* In this case, the RHS is an index b-tree.
     */

@@ -78141,19 +79073,20 @@ static void sqlite3ExprCodeIN(

       ** for this particular IN operator.
       */
       sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
       VdbeCoverage(v);
     }else{
       /* In this branch, the RHS of the IN might contain a NULL and
       ** the presence of a NULL on the RHS makes a difference in the
       ** outcome.
       */
       int j1, j2, j3;
       int j1, j2;
       /* First check to see if the LHS is contained in the RHS.  If so,
       ** then the presence of NULLs in the RHS does not matter, so jump
       ** over all of the code that follows.
       */
       j1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
       VdbeCoverage(v);
       /* Here we begin generating code that runs if the LHS is not
       ** contained within the RHS.  Generate additional code that

@@ -78161,18 +79094,15 @@ static void sqlite3ExprCodeIN(

       ** jump to destIfNull.  If there are no NULLs in the RHS then
       ** jump to destIfFalse.
       */
       j2 = sqlite3VdbeAddOp1(v, OP_NotNull, rRhsHasNull);
       j3 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
       sqlite3VdbeAddOp2(v, OP_Integer, -1, rRhsHasNull);
       sqlite3VdbeJumpHere(v, j3);
       sqlite3VdbeAddOp2(v, OP_AddImm, rRhsHasNull, 1);
       sqlite3VdbeJumpHere(v, j2);
       /* Jump to the appropriate target depending on whether or not
       ** the RHS contains a NULL
       */
       sqlite3VdbeAddOp2(v, OP_If, rRhsHasNull, destIfNull);
       sqlite3VdbeAddOp2(v, OP_If, rRhsHasNull, destIfNull); VdbeCoverage(v);
       sqlite3VdbeAddOp2(v, OP_IfNot, rRhsHasNull, destIfFalse); VdbeCoverage(v);
       j2 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
       VdbeCoverage(v);
       sqlite3VdbeAddOp2(v, OP_Integer, 0, rRhsHasNull);
       sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
       sqlite3VdbeJumpHere(v, j2);
       sqlite3VdbeAddOp2(v, OP_Integer, 1, rRhsHasNull);
       sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
       /* The OP_Found at the top of this branch jumps here when true,
       ** causing the overall IN expression evaluation to fall through.

@@ -78355,6 +79285,11 @@ SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){

 */
 SQLITE_PRIVATE void sqlite3ExprCachePush(Parse *pParse){
   pParse->iCacheLevel++;
 #ifdef SQLITE_DEBUG
   if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
     printf("PUSH to %d\n", pParse->iCacheLevel);
   }
 #endif
 }
 /*

@@ -78368,6 +79303,11 @@ SQLITE_PRIVATE void sqlite3ExprCachePop(Parse *pParse, int N){

   assert( N>0 );
   assert( pParse->iCacheLevel>=N );
   pParse->iCacheLevel -= N;
 #ifdef SQLITE_DEBUG
   if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
     printf("POP  to %d\n", pParse->iCacheLevel);
   }
 #endif
   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
     if( p->iReg && p->iLevel>pParse->iCacheLevel ){
       cacheEntryClear(pParse, p);

@@ -78398,15 +79338,19 @@ static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){

 SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(
   Vdbe *v,        /* The VDBE under construction */
   Table *pTab,    /* The table containing the value */
   int iTabCur,    /* The cursor for this table */
   int iTabCur,    /* The table cursor.  Or the PK cursor for WITHOUT ROWID */
   int iCol,       /* Index of the column to extract */
   int regOut      /* Extract the valud into this register */
   int regOut      /* Extract the value into this register */
 ){
   if( iCol<0 || iCol==pTab->iPKey ){
     sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
   }else{
     int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
     sqlite3VdbeAddOp3(v, op, iTabCur, iCol, regOut);
     int x = iCol;
     if( !HasRowid(pTab) ){
       x = sqlite3ColumnOfIndex(sqlite3PrimaryKeyIndex(pTab), iCol);
     }
     sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut);
   }
   if( iCol>=0 ){
     sqlite3ColumnDefault(v, pTab, iCol, regOut);

@@ -78458,6 +79402,11 @@ SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){

   int i;
   struct yColCache *p;
 #if SQLITE_DEBUG
   if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
     printf("CLEAR\n");
   }
 #endif
   for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
     if( p->iReg ){
       cacheEntryClear(pParse, p);

@@ -78539,6 +79488,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

   int regFree2 = 0;         /* If non-zero free this temporary register */
   int r1, r2, r3, r4;       /* Various register numbers */
   sqlite3 *db = pParse->db; /* The database connection */
   Expr tempX;               /* Temporary expression node */
   assert( target>0 && target<=pParse->nMem );
   if( v==0 ){

@@ -78673,22 +79623,16 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

     case TK_GE:
     case TK_NE:
     case TK_EQ: {
       assert( TK_LT==OP_Lt );
       assert( TK_LE==OP_Le );
       assert( TK_GT==OP_Gt );
       assert( TK_GE==OP_Ge );
       assert( TK_EQ==OP_Eq );
       assert( TK_NE==OP_Ne );
       testcase( op==TK_LT );
       testcase( op==TK_LE );
       testcase( op==TK_GT );
       testcase( op==TK_GE );
       testcase( op==TK_EQ );
       testcase( op==TK_NE );
       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
                   r1, r2, inReg, SQLITE_STOREP2);
       assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
       assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
       assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
       assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
       assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
       assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
       testcase( regFree1==0 );
       testcase( regFree2==0 );
       break;

@@ -78702,6 +79646,8 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

       op = (op==TK_IS) ? TK_EQ : TK_NE;
       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
                   r1, r2, inReg, SQLITE_STOREP2 | SQLITE_NULLEQ);
       VdbeCoverageIf(v, op==TK_EQ);
       VdbeCoverageIf(v, op==TK_NE);
       testcase( regFree1==0 );
       testcase( regFree2==0 );
       break;

@@ -78718,28 +79664,17 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

     case TK_LSHIFT:
     case TK_RSHIFT:
     case TK_CONCAT: {
       assert( TK_AND==OP_And );
       assert( TK_OR==OP_Or );
       assert( TK_PLUS==OP_Add );
       assert( TK_MINUS==OP_Subtract );
       assert( TK_REM==OP_Remainder );
       assert( TK_BITAND==OP_BitAnd );
       assert( TK_BITOR==OP_BitOr );
       assert( TK_SLASH==OP_Divide );
       assert( TK_LSHIFT==OP_ShiftLeft );
       assert( TK_RSHIFT==OP_ShiftRight );
       assert( TK_CONCAT==OP_Concat );
       testcase( op==TK_AND );
       testcase( op==TK_OR );
       testcase( op==TK_PLUS );
       testcase( op==TK_MINUS );
       testcase( op==TK_REM );
       testcase( op==TK_BITAND );
       testcase( op==TK_BITOR );
       testcase( op==TK_SLASH );
       testcase( op==TK_LSHIFT );
       testcase( op==TK_RSHIFT );
       testcase( op==TK_CONCAT );
       assert( TK_AND==OP_And );            testcase( op==TK_AND );
       assert( TK_OR==OP_Or );              testcase( op==TK_OR );
       assert( TK_PLUS==OP_Add );           testcase( op==TK_PLUS );
       assert( TK_MINUS==OP_Subtract );     testcase( op==TK_MINUS );
       assert( TK_REM==OP_Remainder );      testcase( op==TK_REM );
       assert( TK_BITAND==OP_BitAnd );      testcase( op==TK_BITAND );
       assert( TK_BITOR==OP_BitOr );        testcase( op==TK_BITOR );
       assert( TK_SLASH==OP_Divide );       testcase( op==TK_SLASH );
       assert( TK_LSHIFT==OP_ShiftLeft );   testcase( op==TK_LSHIFT );
       assert( TK_RSHIFT==OP_ShiftRight );  testcase( op==TK_RSHIFT );
       assert( TK_CONCAT==OP_Concat );      testcase( op==TK_CONCAT );
       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
       sqlite3VdbeAddOp3(v, op, r2, r1, target);

@@ -78758,8 +79693,10 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

         codeReal(v, pLeft->u.zToken, 1, target);
 #endif
       }else{
         regFree1 = r1 = sqlite3GetTempReg(pParse);
         sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
         tempX.op = TK_INTEGER;
         tempX.flags = EP_IntValue|EP_TokenOnly;
         tempX.u.iValue = 0;
         r1 = sqlite3ExprCodeTemp(pParse, &tempX, &regFree1);
         r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree2);
         sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
         testcase( regFree2==0 );

@@ -78769,10 +79706,8 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

     }
     case TK_BITNOT:
     case TK_NOT: {
       assert( TK_BITNOT==OP_BitNot );
       assert( TK_NOT==OP_Not );
       testcase( op==TK_BITNOT );
       testcase( op==TK_NOT );
       assert( TK_BITNOT==OP_BitNot );   testcase( op==TK_BITNOT );
       assert( TK_NOT==OP_Not );         testcase( op==TK_NOT );
       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
       testcase( regFree1==0 );
       inReg = target;

@@ -78782,14 +79717,14 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

     case TK_ISNULL:
     case TK_NOTNULL: {
       int addr;
       assert( TK_ISNULL==OP_IsNull );
       assert( TK_NOTNULL==OP_NotNull );
       testcase( op==TK_ISNULL );
       testcase( op==TK_NOTNULL );
       assert( TK_ISNULL==OP_IsNull );   testcase( op==TK_ISNULL );
       assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
       sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
       testcase( regFree1==0 );
       addr = sqlite3VdbeAddOp1(v, op, r1);
       VdbeCoverageIf(v, op==TK_ISNULL);
       VdbeCoverageIf(v, op==TK_NOTNULL);
       sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
       sqlite3VdbeJumpHere(v, addr);
       break;

@@ -78804,21 +79739,18 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

       }
       break;
     }
     case TK_CONST_FUNC:
     case TK_FUNCTION: {
       ExprList *pFarg;       /* List of function arguments */
       int nFarg;             /* Number of function arguments */
       FuncDef *pDef;         /* The function definition object */
       int nId;               /* Length of the function name in bytes */
       const char *zId;       /* The function name */
       int constMask = 0;     /* Mask of function arguments that are constant */
       u32 constMask = 0;     /* Mask of function arguments that are constant */
       int i;                 /* Loop counter */
       u8 enc = ENC(db);      /* The text encoding used by this database */
       CollSeq *pColl = 0;    /* A collating sequence */
       assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
       testcase( op==TK_CONST_FUNC );
       testcase( op==TK_FUNCTION );
       if( ExprHasProperty(pExpr, EP_TokenOnly) ){
         pFarg = 0;
       }else{

@@ -78844,6 +79776,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

         sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
         for(i=1; i<nFarg; i++){
           sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
           VdbeCoverage(v);
           sqlite3ExprCacheRemove(pParse, target, 1);
           sqlite3ExprCachePush(pParse);
           sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);

@@ -78862,8 +79795,22 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

         break;
       }
       for(i=0; i<nFarg; i++){
         if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
           testcase( i==31 );
           constMask |= MASKBIT32(i);
         }
         if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
           pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
         }
       }
       if( pFarg ){
         r1 = sqlite3GetTempRange(pParse, nFarg);
         if( constMask ){
           r1 = pParse->nMem+1;
           pParse->nMem += nFarg;
         }else{
           r1 = sqlite3GetTempRange(pParse, nFarg);
         }
         /* For length() and typeof() functions with a column argument,
         ** set the P5 parameter to the OP_Column opcode to OPFLAG_LENGTHARG

@@ -78878,14 +79825,15 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

           if( exprOp==TK_COLUMN || exprOp==TK_AGG_COLUMN ){
             assert( SQLITE_FUNC_LENGTH==OPFLAG_LENGTHARG );
             assert( SQLITE_FUNC_TYPEOF==OPFLAG_TYPEOFARG );
             testcase( (pDef->funcFlags&~SQLITE_FUNC_ENCMASK)
                        ==SQLITE_FUNC_LENGTH );
             pFarg->a[0].pExpr->op2 = pDef->funcFlags&~SQLITE_FUNC_ENCMASK;
             testcase( pDef->funcFlags & OPFLAG_LENGTHARG );
             pFarg->a[0].pExpr->op2 =
                   pDef->funcFlags & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG);
           }
         }
         sqlite3ExprCachePush(pParse);     /* Ticket 2ea2425d34be */
         sqlite3ExprCodeExprList(pParse, pFarg, r1, 1);
         sqlite3ExprCodeExprList(pParse, pFarg, r1,
                                 SQLITE_ECEL_DUP|SQLITE_ECEL_FACTOR);
         sqlite3ExprCachePop(pParse, 1);   /* Ticket 2ea2425d34be */
       }else{
         r1 = 0;

@@ -78909,14 +79857,6 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

         pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
       }
 #endif
       for(i=0; i<nFarg; i++){
         if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
           constMask |= (1<<i);
         }
         if( (pDef->funcFlags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
           pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
         }
       }
       if( pDef->funcFlags & SQLITE_FUNC_NEEDCOLL ){
         if( !pColl ) pColl = db->pDfltColl;
         sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);

@@ -78924,7 +79864,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

       sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
                         (char*)pDef, P4_FUNCDEF);
       sqlite3VdbeChangeP5(v, (u8)nFarg);
       if( nFarg ){
       if( nFarg && constMask==0 ){
         sqlite3ReleaseTempRange(pParse, r1, nFarg);
       }
       break;

@@ -78974,13 +79914,14 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

       r3 = sqlite3GetTempReg(pParse);
       r4 = sqlite3GetTempReg(pParse);
       codeCompare(pParse, pLeft, pRight, OP_Ge,
                   r1, r2, r3, SQLITE_STOREP2);
                   r1, r2, r3, SQLITE_STOREP2);  VdbeCoverage(v);
       pLItem++;
       pRight = pLItem->pExpr;
       sqlite3ReleaseTempReg(pParse, regFree2);
       r2 = sqlite3ExprCodeTemp(pParse, pRight, &regFree2);
       testcase( regFree2==0 );
       codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
       VdbeCoverage(v);
       sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
       sqlite3ReleaseTempReg(pParse, r3);
       sqlite3ReleaseTempReg(pParse, r4);

@@ -79075,7 +80016,6 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

       ExprList *pEList;                 /* List of WHEN terms */
       struct ExprList_item *aListelem;  /* Array of WHEN terms */
       Expr opCompare;                   /* The X==Ei expression */
       Expr cacheX;                      /* Cached expression X */
       Expr *pX;                         /* The X expression */
       Expr *pTest = 0;                  /* X==Ei (form A) or just Ei (form B) */
       VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )

@@ -79087,13 +80027,12 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

       nExpr = pEList->nExpr;
       endLabel = sqlite3VdbeMakeLabel(v);
       if( (pX = pExpr->pLeft)!=0 ){
         cacheX = *pX;
         tempX = *pX;
         testcase( pX->op==TK_COLUMN );
         testcase( pX->op==TK_REGISTER );
         exprToRegister(&cacheX, sqlite3ExprCodeTemp(pParse, pX, &regFree1));
         exprToRegister(&tempX, sqlite3ExprCodeTemp(pParse, pX, &regFree1));
         testcase( regFree1==0 );
         opCompare.op = TK_EQ;
         opCompare.pLeft = &cacheX;
         opCompare.pLeft = &tempX;
         pTest = &opCompare;
         /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
         ** The value in regFree1 might get SCopy-ed into the file result.

@@ -79113,7 +80052,6 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

         testcase( pTest->op==TK_COLUMN );
         sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
         testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
         testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
         sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
         sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
         sqlite3ExprCachePop(pParse, 1);

@@ -79150,9 +80088,10 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

       if( pExpr->affinity==OE_Ignore ){
         sqlite3VdbeAddOp4(
             v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
         VdbeCoverage(v);
       }else{
         sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_TRIGGER,
                               pExpr->affinity, pExpr->u.zToken, 0);
                               pExpr->affinity, pExpr->u.zToken, 0, 0);
       }
       break;

@@ -79165,6 +80104,28 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

 }
 /*
 ** Factor out the code of the given expression to initialization time.
 */
 SQLITE_PRIVATE void sqlite3ExprCodeAtInit(
   Parse *pParse,    /* Parsing context */
   Expr *pExpr,      /* The expression to code when the VDBE initializes */
   int regDest,      /* Store the value in this register */
   u8 reusable       /* True if this expression is reusable */
 ){
   ExprList *p;
   assert( ConstFactorOk(pParse) );
   p = pParse->pConstExpr;
   pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
   p = sqlite3ExprListAppend(pParse, p, pExpr);
   if( p ){
      struct ExprList_item *pItem = &p->a[p->nExpr-1];
      pItem->u.iConstExprReg = regDest;
      pItem->reusable = reusable;
   }
   pParse->pConstExpr = p;
 }
 /*
 ** Generate code to evaluate an expression and store the results
 ** into a register.  Return the register number where the results
 ** are stored.

@@ -79172,15 +80133,40 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)

 ** If the register is a temporary register that can be deallocated,
 ** then write its number into *pReg.  If the result register is not
 ** a temporary, then set *pReg to zero.
 **
 ** If pExpr is a constant, then this routine might generate this
 ** code to fill the register in the initialization section of the
 ** VDBE program, in order to factor it out of the evaluation loop.
 */
 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
   int r1 = sqlite3GetTempReg(pParse);
   int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
   if( r2==r1 ){
     *pReg = r1;
   int r2;
   pExpr = sqlite3ExprSkipCollate(pExpr);
   if( ConstFactorOk(pParse)
    && pExpr->op!=TK_REGISTER
    && sqlite3ExprIsConstantNotJoin(pExpr)
   ){
     ExprList *p = pParse->pConstExpr;
     int i;
     *pReg  = 0;
     if( p ){
       struct ExprList_item *pItem;
       for(pItem=p->a, i=p->nExpr; i>0; pItem++, i--){
         if( pItem->reusable && sqlite3ExprCompare(pItem->pExpr,pExpr,-1)==0 ){
           return pItem->u.iConstExprReg;
         }
       }
     }
     r2 = ++pParse->nMem;
     sqlite3ExprCodeAtInit(pParse, pExpr, r2, 1);
   }else{
     sqlite3ReleaseTempReg(pParse, r1);
     *pReg = 0;
     int r1 = sqlite3GetTempReg(pParse);
     r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
     if( r2==r1 ){
       *pReg = r1;
     }else{
       sqlite3ReleaseTempReg(pParse, r1);
       *pReg = 0;
     }
   }
   return r2;
 }

@@ -79190,7 +80176,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){

 ** results in register target.  The results are guaranteed to appear
 ** in register target.
 */
 SQLITE_PRIVATE int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
   int inReg;
   assert( target>0 && target<=pParse->nMem );

@@ -79203,7 +80189,20 @@ SQLITE_PRIVATE int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){

       sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
     }
   }
   return target;
 }
 /*
 ** Generate code that will evaluate expression pExpr and store the
 ** results in register target.  The results are guaranteed to appear
 ** in register target.  If the expression is constant, then this routine
 ** might choose to code the expression at initialization time.
 */
 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
   if( pParse->okConstFactor && sqlite3ExprIsConstant(pExpr) ){
     sqlite3ExprCodeAtInit(pParse, pExpr, target, 0);
   }else{
     sqlite3ExprCode(pParse, pExpr, target);
   }
 }
 /*

@@ -79218,24 +80217,16 @@ SQLITE_PRIVATE int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){

 ** times.  They are evaluated once and the results of the expression
 ** are reused.
 */
 SQLITE_PRIVATE int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
 SQLITE_PRIVATE void sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
   Vdbe *v = pParse->pVdbe;
   int inReg;
   inReg = sqlite3ExprCode(pParse, pExpr, target);
   int iMem;
   assert( target>0 );
   /* This routine is called for terms to INSERT or UPDATE.  And the only
   ** other place where expressions can be converted into TK_REGISTER is
   ** in WHERE clause processing.  So as currently implemented, there is
   ** no way for a TK_REGISTER to exist here.  But it seems prudent to
   ** keep the ALWAYS() in case the conditions above change with future
   ** modifications or enhancements. */
   if( ALWAYS(pExpr->op!=TK_REGISTER) ){
     int iMem;
     iMem = ++pParse->nMem;
     sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
     exprToRegister(pExpr, iMem);
   }
   return inReg;
   assert( pExpr->op!=TK_REGISTER );
   sqlite3ExprCode(pParse, pExpr, target);
   iMem = ++pParse->nMem;
   sqlite3VdbeAddOp2(v, OP_Copy, target, iMem);
   exprToRegister(pExpr, iMem);
 }
 #if defined(SQLITE_ENABLE_TREE_EXPLAIN)

@@ -79360,7 +80351,6 @@ SQLITE_PRIVATE void sqlite3ExplainExpr(Vdbe *pOut, Expr *pExpr){

     }
     case TK_AGG_FUNCTION:
     case TK_CONST_FUNC:
     case TK_FUNCTION: {
       ExprList *pFarg;       /* List of function arguments */
       if( ExprHasProperty(pExpr, EP_TokenOnly) ){

@@ -79512,163 +80502,50 @@ SQLITE_PRIVATE void sqlite3ExplainExprList(Vdbe *pOut, ExprList *pList){

 #endif /* SQLITE_DEBUG */
 /*
 ** Return TRUE if pExpr is an constant expression that is appropriate
 ** for factoring out of a loop.  Appropriate expressions are:
 **
 **    *  Any expression that evaluates to two or more opcodes.
 **
 **    *  Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
 **       or OP_Variable that does not need to be placed in a
 **       specific register.
 **
 ** There is no point in factoring out single-instruction constant
 ** expressions that need to be placed in a particular register.
 ** We could factor them out, but then we would end up adding an
 ** OP_SCopy instruction to move the value into the correct register
 ** later.  We might as well just use the original instruction and
 ** avoid the OP_SCopy.
 */
 static int isAppropriateForFactoring(Expr *p){
   if( !sqlite3ExprIsConstantNotJoin(p) ){
     return 0;  /* Only constant expressions are appropriate for factoring */
   }
   if( (p->flags & EP_FixedDest)==0 ){
     return 1;  /* Any constant without a fixed destination is appropriate */
   }
   while( p->op==TK_UPLUS ) p = p->pLeft;
   switch( p->op ){
 #ifndef SQLITE_OMIT_BLOB_LITERAL
     case TK_BLOB:
 #endif
     case TK_VARIABLE:
     case TK_INTEGER:
     case TK_FLOAT:
     case TK_NULL:
     case TK_STRING: {
       testcase( p->op==TK_BLOB );
       testcase( p->op==TK_VARIABLE );
       testcase( p->op==TK_INTEGER );
       testcase( p->op==TK_FLOAT );
       testcase( p->op==TK_NULL );
       testcase( p->op==TK_STRING );
       /* Single-instruction constants with a fixed destination are
       ** better done in-line.  If we factor them, they will just end
       ** up generating an OP_SCopy to move the value to the destination
       ** register. */
       return 0;
     }
     case TK_UMINUS: {
       if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
         return 0;
       }
       break;
     }
     default: {
       break;
     }
   }
   return 1;
 }
 /*
 ** If pExpr is a constant expression that is appropriate for
 ** factoring out of a loop, then evaluate the expression
 ** into a register and convert the expression into a TK_REGISTER
 ** expression.
 */
 static int evalConstExpr(Walker *pWalker, Expr *pExpr){
   Parse *pParse = pWalker->pParse;
   switch( pExpr->op ){
     case TK_IN:
     case TK_REGISTER: {
       return WRC_Prune;
     }
     case TK_COLLATE: {
       return WRC_Continue;
     }
     case TK_FUNCTION:
     case TK_AGG_FUNCTION:
     case TK_CONST_FUNC: {
       /* The arguments to a function have a fixed destination.
       ** Mark them this way to avoid generated unneeded OP_SCopy
       ** instructions.
       */
       ExprList *pList = pExpr->x.pList;
       assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
       if( pList ){
         int i = pList->nExpr;
         struct ExprList_item *pItem = pList->a;
         for(; i>0; i--, pItem++){
           if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
         }
       }
       break;
     }
   }
   if( isAppropriateForFactoring(pExpr) ){
     int r1 = ++pParse->nMem;
     int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
     /* If r2!=r1, it means that register r1 is never used.  That is harmless
     ** but suboptimal, so we want to know about the situation to fix it.
     ** Hence the following assert: */
     assert( r2==r1 );
     exprToRegister(pExpr, r2);
     return WRC_Prune;
   }
   return WRC_Continue;
 }
 /*
 ** Preevaluate constant subexpressions within pExpr and store the
 ** results in registers.  Modify pExpr so that the constant subexpresions
 ** are TK_REGISTER opcodes that refer to the precomputed values.
 **
 ** This routine is a no-op if the jump to the cookie-check code has
 ** already occur.  Since the cookie-check jump is generated prior to
 ** any other serious processing, this check ensures that there is no
 ** way to accidently bypass the constant initializations.
 **
 ** This routine is also a no-op if the SQLITE_FactorOutConst optimization
 ** is disabled via the sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS)
 ** interface.  This allows test logic to verify that the same answer is
 ** obtained for queries regardless of whether or not constants are
 ** precomputed into registers or if they are inserted in-line.
 */
 SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
   Walker w;
   if( pParse->cookieGoto ) return;
   if( OptimizationDisabled(pParse->db, SQLITE_FactorOutConst) ) return;
   memset(&w, 0, sizeof(w));
   w.xExprCallback = evalConstExpr;
   w.pParse = pParse;
   sqlite3WalkExpr(&w, pExpr);
 }
 /*
 ** Generate code that pushes the value of every element of the given
 ** expression list into a sequence of registers beginning at target.
 **
 ** Return the number of elements evaluated.
 **
 ** The SQLITE_ECEL_DUP flag prevents the arguments from being
 ** filled using OP_SCopy.  OP_Copy must be used instead.
 **
 ** The SQLITE_ECEL_FACTOR argument allows constant arguments to be
 ** factored out into initialization code.
 */
 SQLITE_PRIVATE int sqlite3ExprCodeExprList(
   Parse *pParse,     /* Parsing context */
   ExprList *pList,   /* The expression list to be coded */
   int target,        /* Where to write results */
   int doHardCopy     /* Make a hard copy of every element */
   u8 flags           /* SQLITE_ECEL_* flags */
 ){
   struct ExprList_item *pItem;
   int i, n;
   u8 copyOp = (flags & SQLITE_ECEL_DUP) ? OP_Copy : OP_SCopy;
   assert( pList!=0 );
   assert( target>0 );
   assert( pParse->pVdbe!=0 );  /* Never gets this far otherwise */
   n = pList->nExpr;
   if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR;
   for(pItem=pList->a, i=0; i<n; i++, pItem++){
     Expr *pExpr = pItem->pExpr;
     int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
     if( inReg!=target+i ){
       sqlite3VdbeAddOp2(pParse->pVdbe, doHardCopy ? OP_Copy : OP_SCopy,
                         inReg, target+i);
     if( (flags & SQLITE_ECEL_FACTOR)!=0 && sqlite3ExprIsConstant(pExpr) ){
       sqlite3ExprCodeAtInit(pParse, pExpr, target+i, 0);
     }else{
       int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
       if( inReg!=target+i ){
         VdbeOp *pOp;
         Vdbe *v = pParse->pVdbe;
         if( copyOp==OP_Copy
          && (pOp=sqlite3VdbeGetOp(v, -1))->opcode==OP_Copy
          && pOp->p1+pOp->p3+1==inReg
          && pOp->p2+pOp->p3+1==target+i
         ){
           pOp->p3++;
         }else{
           sqlite3VdbeAddOp2(v, copyOp, inReg, target+i);
         }
       }
     }
   }
   return n;

@@ -79758,8 +80635,8 @@ SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int

     case TK_AND: {
       int d2 = sqlite3VdbeMakeLabel(v);
       testcase( jumpIfNull==0 );
       sqlite3ExprCachePush(pParse);
       sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
       sqlite3ExprCachePush(pParse);
       sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
       sqlite3VdbeResolveLabel(v, d2);
       sqlite3ExprCachePop(pParse, 1);

@@ -79768,7 +80645,9 @@ SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int

     case TK_OR: {
       testcase( jumpIfNull==0 );
       sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
       sqlite3ExprCachePush(pParse);
       sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
       sqlite3ExprCachePop(pParse, 1);
       break;
     }
     case TK_NOT: {

@@ -79782,23 +80661,17 @@ SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int

     case TK_GE:
     case TK_NE:
     case TK_EQ: {
       assert( TK_LT==OP_Lt );
       assert( TK_LE==OP_Le );
       assert( TK_GT==OP_Gt );
       assert( TK_GE==OP_Ge );
       assert( TK_EQ==OP_Eq );
       assert( TK_NE==OP_Ne );
       testcase( op==TK_LT );
       testcase( op==TK_LE );
       testcase( op==TK_GT );
       testcase( op==TK_GE );
       testcase( op==TK_EQ );
       testcase( op==TK_NE );
       testcase( jumpIfNull==0 );
       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
                   r1, r2, dest, jumpIfNull);
       assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
       assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
       assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
       assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
       assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
       assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
       testcase( regFree1==0 );
       testcase( regFree2==0 );
       break;

@@ -79812,18 +80685,20 @@ SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int

       op = (op==TK_IS) ? TK_EQ : TK_NE;
       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
                   r1, r2, dest, SQLITE_NULLEQ);
       VdbeCoverageIf(v, op==TK_EQ);
       VdbeCoverageIf(v, op==TK_NE);
       testcase( regFree1==0 );
       testcase( regFree2==0 );
       break;
     }
     case TK_ISNULL:
     case TK_NOTNULL: {
       assert( TK_ISNULL==OP_IsNull );
       assert( TK_NOTNULL==OP_NotNull );
       testcase( op==TK_ISNULL );
       testcase( op==TK_NOTNULL );
       assert( TK_ISNULL==OP_IsNull );   testcase( op==TK_ISNULL );
       assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
       sqlite3VdbeAddOp2(v, op, r1, dest);
       VdbeCoverageIf(v, op==TK_ISNULL);
       VdbeCoverageIf(v, op==TK_NOTNULL);
       testcase( regFree1==0 );
       break;
     }

@@ -79843,10 +80718,17 @@ SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int

     }
 #endif
     default: {
       r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
       sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
       testcase( regFree1==0 );
       testcase( jumpIfNull==0 );
       if( exprAlwaysTrue(pExpr) ){
         sqlite3VdbeAddOp2(v, OP_Goto, 0, dest);
       }else if( exprAlwaysFalse(pExpr) ){
         /* No-op */
       }else{
         r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
         sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
         VdbeCoverage(v);
         testcase( regFree1==0 );
         testcase( jumpIfNull==0 );
       }
       break;
     }
   }

@@ -79909,14 +80791,16 @@ SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int

     case TK_AND: {
       testcase( jumpIfNull==0 );
       sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
       sqlite3ExprCachePush(pParse);
       sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
       sqlite3ExprCachePop(pParse, 1);
       break;
     }
     case TK_OR: {
       int d2 = sqlite3VdbeMakeLabel(v);
       testcase( jumpIfNull==0 );
       sqlite3ExprCachePush(pParse);
       sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
       sqlite3ExprCachePush(pParse);
       sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
       sqlite3VdbeResolveLabel(v, d2);
       sqlite3ExprCachePop(pParse, 1);

@@ -79933,17 +80817,17 @@ SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int

     case TK_GE:
     case TK_NE:
     case TK_EQ: {
       testcase( op==TK_LT );
       testcase( op==TK_LE );
       testcase( op==TK_GT );
       testcase( op==TK_GE );
       testcase( op==TK_EQ );
       testcase( op==TK_NE );
       testcase( jumpIfNull==0 );
       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
       r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, &regFree2);
       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
                   r1, r2, dest, jumpIfNull);
       assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
       assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
       assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
       assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
       assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
       assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
       testcase( regFree1==0 );
       testcase( regFree2==0 );
       break;

@@ -79957,16 +80841,18 @@ SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int

       op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
       codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
                   r1, r2, dest, SQLITE_NULLEQ);
       VdbeCoverageIf(v, op==TK_EQ);
       VdbeCoverageIf(v, op==TK_NE);
       testcase( regFree1==0 );
       testcase( regFree2==0 );
       break;
     }
     case TK_ISNULL:
     case TK_NOTNULL: {
       testcase( op==TK_ISNULL );
       testcase( op==TK_NOTNULL );
       r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
       sqlite3VdbeAddOp2(v, op, r1, dest);
       testcase( op==TK_ISNULL );   VdbeCoverageIf(v, op==TK_ISNULL);
       testcase( op==TK_NOTNULL );  VdbeCoverageIf(v, op==TK_NOTNULL);
       testcase( regFree1==0 );
       break;
     }

@@ -79988,10 +80874,17 @@ SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int

     }
 #endif
     default: {
       r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
       sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
       testcase( regFree1==0 );
       testcase( jumpIfNull==0 );
       if( exprAlwaysFalse(pExpr) ){
         sqlite3VdbeAddOp2(v, OP_Goto, 0, dest);
       }else if( exprAlwaysTrue(pExpr) ){
         /* no-op */
       }else{
         r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
         sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
         VdbeCoverage(v);
         testcase( regFree1==0 );
         testcase( jumpIfNull==0 );
       }
       break;
     }
   }

@@ -80022,16 +80915,18 @@ SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int

 ** an incorrect 0 or 1 could lead to a malfunction.
 */
 SQLITE_PRIVATE int sqlite3ExprCompare(Expr *pA, Expr *pB, int iTab){
   if( pA==0||pB==0 ){
   u32 combinedFlags;
   if( pA==0 || pB==0 ){
     return pB==pA ? 0 : 2;
   }
   assert( !ExprHasProperty(pA, EP_TokenOnly|EP_Reduced) );
   assert( !ExprHasProperty(pB, EP_TokenOnly|EP_Reduced) );
   if( ExprHasProperty(pA, EP_xIsSelect) || ExprHasProperty(pB, EP_xIsSelect) ){
   combinedFlags = pA->flags | pB->flags;
   if( combinedFlags & EP_IntValue ){
     if( (pA->flags&pB->flags&EP_IntValue)!=0 && pA->u.iValue==pB->u.iValue ){
       return 0;
     }
     return 2;
   }
   if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2;
   if( pA->op!=pB->op && (pA->op!=TK_REGISTER || pA->op2!=pB->op) ){
   if( pA->op!=pB->op ){
     if( pA->op==TK_COLLATE && sqlite3ExprCompare(pA->pLeft, pB, iTab)<2 ){
       return 1;
     }

@@ -80040,23 +80935,23 @@ SQLITE_PRIVATE int sqlite3ExprCompare(Expr *pA, Expr *pB, int iTab){

     }
     return 2;
   }
   if( sqlite3ExprCompare(pA->pLeft, pB->pLeft, iTab) ) return 2;
   if( sqlite3ExprCompare(pA->pRight, pB->pRight, iTab) ) return 2;
   if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2;
   if( pA->iColumn!=pB->iColumn ) return 2;
   if( pA->iTable!=pB->iTable
    && pA->op!=TK_REGISTER
    && (pA->iTable!=iTab || NEVER(pB->iTable>=0)) ) return 2;
   if( ExprHasProperty(pA, EP_IntValue) ){
     if( !ExprHasProperty(pB, EP_IntValue) || pA->u.iValue!=pB->u.iValue ){
       return 2;
     }
   }else if( pA->op!=TK_COLUMN && ALWAYS(pA->op!=TK_AGG_COLUMN) && pA->u.zToken){
     if( ExprHasProperty(pB, EP_IntValue) || NEVER(pB->u.zToken==0) ) return 2;
   if( pA->op!=TK_COLUMN && ALWAYS(pA->op!=TK_AGG_COLUMN) && pA->u.zToken ){
     if( strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
       return pA->op==TK_COLLATE ? 1 : 2;
     }
   }
   if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2;
   if( ALWAYS((combinedFlags & EP_TokenOnly)==0) ){
     if( combinedFlags & EP_xIsSelect ) return 2;
     if( sqlite3ExprCompare(pA->pLeft, pB->pLeft, iTab) ) return 2;
     if( sqlite3ExprCompare(pA->pRight, pB->pRight, iTab) ) return 2;
     if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2;
     if( ALWAYS((combinedFlags & EP_Reduced)==0) ){
       if( pA->iColumn!=pB->iColumn ) return 2;
       if( pA->iTable!=pB->iTable
        && (pA->iTable!=iTab || NEVER(pB->iTable>=0)) ) return 2;
     }
   }
   return 0;
 }

@@ -80533,8 +81428,8 @@ static void renameTableFunc(

       assert( len>0 );
     } while( token!=TK_LP && token!=TK_USING );
     zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql,
        zTableName, tname.z+tname.n);
     zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", (int)(((u8*)tname.z) - zSql),
        zSql, zTableName, tname.z+tname.n);
     sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
   }
 }

@@ -80586,7 +81481,7 @@ static void renameParentFunc(

       sqlite3Dequote(zParent);
       if( 0==sqlite3StrICmp((const char *)zOld, zParent) ){
         char *zOut = sqlite3MPrintf(db, "%s%.*s\"%w\"",
             (zOutput?zOutput:""), z-zInput, zInput, (const char *)zNew
             (zOutput?zOutput:""), (int)(z-zInput), zInput, (const char *)zNew
         );
         sqlite3DbFree(db, zOutput);
         zOutput = zOut;

@@ -80672,8 +81567,8 @@ static void renameTriggerFunc(

     /* Variable tname now contains the token that is the old table-name
     ** in the CREATE TRIGGER statement.
     */
     zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql,
        zTableName, tname.z+tname.n);
     zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", (int)(((u8*)tname.z) - zSql),
        zSql, zTableName, tname.z+tname.n);
     sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
   }
 }

@@ -80925,7 +81820,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(

   }
 #endif
   /* Begin a transaction and code the VerifyCookie for database iDb.
   /* Begin a transaction for database iDb.
   ** Then modify the schema cookie (since the ALTER TABLE modifies the
   ** schema). Open a statement transaction if the table is a virtual
   ** table.

@@ -81061,6 +81956,7 @@ SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minForm

     sqlite3VdbeUsesBtree(v, iDb);
     sqlite3VdbeAddOp2(v, OP_Integer, minFormat, r2);
     j1 = sqlite3VdbeAddOp3(v, OP_Ge, r2, 0, r1);
     sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); VdbeCoverage(v);
     sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, r2);
     sqlite3VdbeJumpHere(v, j1);
     sqlite3ReleaseTempReg(pParse, r1);

@@ -81528,8 +82424,7 @@ static void openStatTable(

   /* Open the sqlite_stat[134] tables for writing. */
   for(i=0; aTable[i].zCols; i++){
     assert( i<ArraySize(aTable) );
     sqlite3VdbeAddOp3(v, OP_OpenWrite, iStatCur+i, aRoot[i], iDb);
     sqlite3VdbeChangeP4(v, -1, (char *)3, P4_INT32);
     sqlite3VdbeAddOp4Int(v, OP_OpenWrite, iStatCur+i, aRoot[i], iDb, 3);
     sqlite3VdbeChangeP5(v, aCreateTbl[i]);
   }
 }

@@ -81553,7 +82448,11 @@ struct Stat4Sample {

   tRowcnt *anDLt;                 /* sqlite_stat4.nDLt */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   tRowcnt *anLt;                  /* sqlite_stat4.nLt */
   i64 iRowid;                     /* Rowid in main table of the key */
   union {
     i64 iRowid;                     /* Rowid in main table of the key */
     u8 *aRowid;                     /* Key for WITHOUT ROWID tables */
   } u;
   u32 nRowid;                     /* Sizeof aRowid[] */
   u8 isPSample;                   /* True if a periodic sample */
   int iCol;                       /* If !isPSample, the reason for inclusion */
   u32 iHash;                      /* Tiebreaker hash */

@@ -81566,13 +82465,87 @@ struct Stat4Accum {

   int mxSample;             /* Maximum number of samples to accumulate */
   Stat4Sample current;      /* Current row as a Stat4Sample */
   u32 iPrn;                 /* Pseudo-random number used for sampling */
   Stat4Sample *aBest;       /* Array of (nCol-1) best samples */
   Stat4Sample *aBest;       /* Array of nCol best samples */
   int iMin;                 /* Index in a[] of entry with minimum score */
   int nSample;              /* Current number of samples */
   int iGet;                 /* Index of current sample accessed by stat_get() */
   Stat4Sample *a;           /* Array of mxSample Stat4Sample objects */
   sqlite3 *db;              /* Database connection, for malloc() */
 };
 /* Reclaim memory used by a Stat4Sample
 */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
 static void sampleClear(sqlite3 *db, Stat4Sample *p){
   assert( db!=0 );
   if( p->nRowid ){
     sqlite3DbFree(db, p->u.aRowid);
     p->nRowid = 0;
   }
 }
 #endif
 /* Initialize the BLOB value of a ROWID
 */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
 static void sampleSetRowid(sqlite3 *db, Stat4Sample *p, int n, const u8 *pData){
   assert( db!=0 );
   if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
   p->u.aRowid = sqlite3DbMallocRaw(db, n);
   if( p->u.aRowid ){
     p->nRowid = n;
     memcpy(p->u.aRowid, pData, n);
   }else{
     p->nRowid = 0;
   }
 }
 #endif
 /* Initialize the INTEGER value of a ROWID.
 */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
 static void sampleSetRowidInt64(sqlite3 *db, Stat4Sample *p, i64 iRowid){
   assert( db!=0 );
   if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
   p->nRowid = 0;
   p->u.iRowid = iRowid;
 }
 #endif
 /*
 ** Copy the contents of object (*pFrom) into (*pTo).
 */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
 static void sampleCopy(Stat4Accum *p, Stat4Sample *pTo, Stat4Sample *pFrom){
   pTo->isPSample = pFrom->isPSample;
   pTo->iCol = pFrom->iCol;
   pTo->iHash = pFrom->iHash;
   memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
   memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
   memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
   if( pFrom->nRowid ){
     sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid);
   }else{
     sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid);
   }
 }
 #endif
 /*
 ** Reclaim all memory of a Stat4Accum structure.
 */
 static void stat4Destructor(void *pOld){
   Stat4Accum *p = (Stat4Accum*)pOld;
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   int i;
   for(i=0; i<p->nCol; i++) sampleClear(p->db, p->aBest+i);
   for(i=0; i<p->mxSample; i++) sampleClear(p->db, p->a+i);
   sampleClear(p->db, &p->current);
 #endif
   sqlite3DbFree(p->db, p);
 }
 /*
 ** Implementation of the stat_init(N,C) SQL function. The two parameters
 ** are the number of rows in the table or index (C) and the number of columns

@@ -81591,6 +82564,7 @@ static void statInit(

   int nCol;                       /* Number of columns in index being sampled */
   int nColUp;                     /* nCol rounded up for alignment */
   int n;                          /* Bytes of space to allocate */
   sqlite3 *db;                    /* Database connection */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   int mxSample = SQLITE_STAT4_SAMPLES;
 #endif

@@ -81607,16 +82581,18 @@ static void statInit(

     + sizeof(tRowcnt)*nColUp                  /* Stat4Accum.anDLt */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
     + sizeof(tRowcnt)*nColUp                  /* Stat4Accum.anLt */
     + sizeof(Stat4Sample)*(nCol+mxSample)   /* Stat4Accum.aBest[], a[] */
     + sizeof(Stat4Sample)*(nCol+mxSample)     /* Stat4Accum.aBest[], a[] */
     + sizeof(tRowcnt)*3*nColUp*(nCol+mxSample)
 #endif
   ;
   p = sqlite3MallocZero(n);
   db = sqlite3_context_db_handle(context);
   p = sqlite3DbMallocZero(db, n);
   if( p==0 ){
     sqlite3_result_error_nomem(context);
     return;
   }
   p->db = db;
   p->nRow = 0;
   p->nCol = nCol;
   p->current.anDLt = (tRowcnt*)&p[1];

@@ -81651,7 +82627,7 @@ static void statInit(

 #endif
   /* Return a pointer to the allocated object to the caller */
   sqlite3_result_blob(context, p, sizeof(p), sqlite3_free);
   sqlite3_result_blob(context, p, sizeof(p), stat4Destructor);
 }
 static const FuncDef statInitFuncdef = {
 +IsStat34,      /* nArg */

@@ -81726,24 +82702,11 @@ static int sampleIsBetter(

 }
 /*
 ** Copy the contents of object (*pFrom) into (*pTo).
 */
 static void sampleCopy(Stat4Accum *p, Stat4Sample *pTo, Stat4Sample *pFrom){
   pTo->iRowid = pFrom->iRowid;
   pTo->isPSample = pFrom->isPSample;
   pTo->iCol = pFrom->iCol;
   pTo->iHash = pFrom->iHash;
   memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
   memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
   memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
 }
 /*
 ** Copy the contents of sample *pNew into the p->a[] array. If necessary,
 ** remove the least desirable sample from p->a[] to make room.
 */
 static void sampleInsert(Stat4Accum *p, Stat4Sample *pNew, int nEqZero){
   Stat4Sample *pSample;
   Stat4Sample *pSample = 0;
   int i;
   assert( IsStat4 || nEqZero==0 );

@@ -81783,8 +82746,10 @@ static void sampleInsert(Stat4Accum *p, Stat4Sample *pNew, int nEqZero){

     tRowcnt *anEq = pMin->anEq;
     tRowcnt *anLt = pMin->anLt;
     tRowcnt *anDLt = pMin->anDLt;
     sampleClear(p->db, pMin);
     memmove(pMin, &pMin[1], sizeof(p->a[0])*(p->nSample-p->iMin-1));
     pSample = &p->a[p->nSample-1];
     pSample->nRowid = 0;
     pSample->anEq = anEq;
     pSample->anDLt = anDLt;
     pSample->anLt = anLt;

@@ -81881,16 +82846,17 @@ static void samplePushPrevious(Stat4Accum *p, int iChng){

 }
 /*
 ** Implementation of the stat_push SQL function:  stat_push(P,R,C)
 ** Implementation of the stat_push SQL function:  stat_push(P,C,R)
 ** Arguments:
 **
 **    P     Pointer to the Stat4Accum object created by stat_init()
 **    C     Index of left-most column to differ from previous row
 **    R     Rowid for the current row
 **    R     Rowid for the current row.  Might be a key record for
 **          WITHOUT ROWID tables.
 **
 ** The SQL function always returns NULL.
 **
 ** The R parameter is only used for STAT3 and STAT4.
 ** The R parameter is only used for STAT3 and STAT4
 */
 static void statPush(
   sqlite3_context *context,

@@ -81930,7 +82896,12 @@ static void statPush(

   }
   p->nRow++;
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   p->current.iRowid = sqlite3_value_int64(argv[2]);
   if( sqlite3_value_type(argv[2])==SQLITE_INTEGER ){
     sampleSetRowidInt64(p->db, &p->current, sqlite3_value_int64(argv[2]));
   }else{
     sampleSetRowid(p->db, &p->current, sqlite3_value_bytes(argv[2]),
                                        sqlite3_value_blob(argv[2]));
   }
   p->current.iHash = p->iPrn = p->iPrn*1103515245 + 12345;
 #endif

@@ -82054,7 +83025,13 @@ static void statGet(

       p->iGet = 0;
     }
     if( p->iGet<p->nSample ){
       sqlite3_result_int64(context, p->a[p->iGet].iRowid);
       Stat4Sample *pS = p->a + p->iGet;
       if( pS->nRowid==0 ){
         sqlite3_result_int64(context, pS->u.iRowid);
       }else{
         sqlite3_result_blob(context, pS->u.aRowid, pS->nRowid,
                             SQLITE_TRANSIENT);
       }
     }
   }else{
     tRowcnt *aCnt = 0;

@@ -82191,22 +83168,26 @@ static void analyzeOneTable(

   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
     int nCol;                     /* Number of columns indexed by pIdx */
     KeyInfo *pKey;                /* KeyInfo structure for pIdx */
     int *aGotoChng;               /* Array of jump instruction addresses */
     int addrRewind;               /* Address of "OP_Rewind iIdxCur" */
     int addrGotoChng0;            /* Address of "Goto addr_chng_0" */
     int addrNextRow;              /* Address of "next_row:" */
     const char *zIdxName;         /* Name of the index */
     if( pOnlyIdx && pOnlyIdx!=pIdx ) continue;
     if( pIdx->pPartIdxWhere==0 ) needTableCnt = 0;
     VdbeNoopComment((v, "Begin analysis of %s", pIdx->zName));
     nCol = pIdx->nColumn;
     nCol = pIdx->nKeyCol;
     aGotoChng = sqlite3DbMallocRaw(db, sizeof(int)*(nCol+1));
     if( aGotoChng==0 ) continue;
     pKey = sqlite3IndexKeyinfo(pParse, pIdx);
     /* Populate the register containing the index name. */
     sqlite3VdbeAddOp4(v, OP_String8, 0, regIdxname, 0, pIdx->zName, 0);
     if( pIdx->autoIndex==2 && !HasRowid(pTab) ){
       zIdxName = pTab->zName;
     }else{
       zIdxName = pIdx->zName;
     }
     sqlite3VdbeAddOp4(v, OP_String8, 0, regIdxname, 0, zIdxName, 0);
     /*
     ** Pseudo-code for loop that calls stat_push():

@@ -82249,7 +83230,7 @@ static void analyzeOneTable(

     /* Open a read-only cursor on the index being analyzed. */
     assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
     sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
     sqlite3VdbeChangeP4(v, -1, (char*)pKey, P4_KEYINFO_HANDOFF);
     sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
     VdbeComment((v, "%s", pIdx->zName));
     /* Invoke the stat_init() function. The arguments are:

@@ -82276,6 +83257,7 @@ static void analyzeOneTable(

     **
     */
     addrRewind = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur);
     VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Integer, 0, regChng);
     addrGotoChng0 = sqlite3VdbeAddOp0(v, OP_Goto);

@@ -82297,6 +83279,7 @@ static void analyzeOneTable(

       aGotoChng[i] =
       sqlite3VdbeAddOp4(v, OP_Ne, regTemp, 0, regPrev+i, pColl, P4_COLLSEQ);
       sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
       VdbeCoverage(v);
     }
     sqlite3VdbeAddOp2(v, OP_Integer, nCol, regChng);
     aGotoChng[nCol] = sqlite3VdbeAddOp0(v, OP_Goto);

@@ -82323,14 +83306,27 @@ static void analyzeOneTable(

     */
     sqlite3VdbeJumpHere(v, aGotoChng[nCol]);
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
     sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, regRowid);
     assert( regRowid==(regStat4+2) );
     if( HasRowid(pTab) ){
       sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, regRowid);
     }else{
       Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
       int j, k, regKey;
       regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol);
       for(j=0; j<pPk->nKeyCol; j++){
         k = sqlite3ColumnOfIndex(pIdx, pPk->aiColumn[j]);
         sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, regKey+j);
         VdbeComment((v, "%s", pTab->aCol[pPk->aiColumn[j]].zName));
       }
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regKey, pPk->nKeyCol, regRowid);
       sqlite3ReleaseTempRange(pParse, regKey, pPk->nKeyCol);
     }
 #endif
     assert( regChng==(regStat4+1) );
     sqlite3VdbeAddOp3(v, OP_Function, 1, regStat4, regTemp);
     sqlite3VdbeChangeP4(v, -1, (char*)&statPushFuncdef, P4_FUNCDEF);
     sqlite3VdbeChangeP5(v, 2+IsStat34);
     sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow);
     sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v);
     /* Add the entry to the stat1 table. */
     callStatGet(v, regStat4, STAT_GET_STAT1, regStat1);

@@ -82350,30 +83346,36 @@ static void analyzeOneTable(

       int regSampleRowid = regCol + nCol;
       int addrNext;
       int addrIsNull;
       u8 seekOp = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
       pParse->nMem = MAX(pParse->nMem, regCol+nCol+1);
       addrNext = sqlite3VdbeCurrentAddr(v);
       callStatGet(v, regStat4, STAT_GET_ROWID, regSampleRowid);
       addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regSampleRowid);
       VdbeCoverage(v);
       callStatGet(v, regStat4, STAT_GET_NEQ, regEq);
       callStatGet(v, regStat4, STAT_GET_NLT, regLt);
       callStatGet(v, regStat4, STAT_GET_NDLT, regDLt);
       sqlite3VdbeAddOp3(v, OP_NotExists, iTabCur, addrNext, regSampleRowid);
       sqlite3VdbeAddOp4Int(v, seekOp, iTabCur, addrNext, regSampleRowid, 0);
       /* We know that the regSampleRowid row exists because it was read by
       ** the previous loop.  Thus the not-found jump of seekOp will never
       ** be taken */
       VdbeCoverageNeverTaken(v);
 #ifdef SQLITE_ENABLE_STAT3
       sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
                                       pIdx->aiColumn[0], regSample);
 #else
       for(i=0; i<nCol; i++){
         int iCol = pIdx->aiColumn[i];
         i16 iCol = pIdx->aiColumn[i];
         sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, iCol, regCol+i);
       }
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol+1, regSample);
 #endif
       sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 6, regTemp, "bbbbbb", 0);
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regTabname, 6, regTemp);
       sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur+1, regNewRowid);
       sqlite3VdbeAddOp3(v, OP_Insert, iStatCur+1, regTemp, regNewRowid);
       sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNext);
       sqlite3VdbeAddOp2(v, OP_Goto, 1, addrNext); /* P1==1 for end-of-loop */
       sqlite3VdbeJumpHere(v, addrIsNull);
     }
 #endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */

@@ -82390,7 +83392,7 @@ static void analyzeOneTable(

   if( pOnlyIdx==0 && needTableCnt ){
     VdbeComment((v, "%s", pTab->zName));
     sqlite3VdbeAddOp2(v, OP_Count, iTabCur, regStat1);
     jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1);
     jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname);
     sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "aaa", 0);
     sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);

@@ -82613,15 +83615,17 @@ static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){

   if( pTable==0 ){
     return 0;
   }
   if( argv[1] ){
     pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase);
   }else{
   if( argv[1]==0 ){
     pIndex = 0;
   }else if( sqlite3_stricmp(argv[0],argv[1])==0 ){
     pIndex = sqlite3PrimaryKeyIndex(pTable);
   }else{
     pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase);
   }
   z = argv[2];
   if( pIndex ){
     decodeIntArray((char*)z, pIndex->nColumn+1, pIndex->aiRowEst, pIndex);
     decodeIntArray((char*)z, pIndex->nKeyCol+1, pIndex->aiRowEst, pIndex);
     if( pIndex->pPartIdxWhere==0 ) pTable->nRowEst = pIndex->aiRowEst[0];
   }else{
     Index fakeIdx;

@@ -82667,7 +83671,7 @@ static void initAvgEq(Index *pIdx){

     IndexSample *aSample = pIdx->aSample;
     IndexSample *pFinal = &aSample[pIdx->nSample-1];
     int iCol;
     for(iCol=0; iCol<pIdx->nColumn; iCol++){
     for(iCol=0; iCol<pIdx->nKeyCol; iCol++){
       int i;                    /* Used to iterate through samples */
       tRowcnt sumEq = 0;        /* Sum of the nEq values */
       tRowcnt nSum = 0;         /* Number of terms contributing to sumEq */

@@ -82696,6 +83700,23 @@ static void initAvgEq(Index *pIdx){

 }
 /*
 ** Look up an index by name.  Or, if the name of a WITHOUT ROWID table
 ** is supplied instead, find the PRIMARY KEY index for that table.
 */
 static Index *findIndexOrPrimaryKey(
   sqlite3 *db,
   const char *zName,
   const char *zDb
 ){
   Index *pIdx = sqlite3FindIndex(db, zName, zDb);
   if( pIdx==0 ){
     Table *pTab = sqlite3FindTable(db, zName, zDb);
     if( pTab && !HasRowid(pTab) ) pIdx = sqlite3PrimaryKeyIndex(pTab);
   }
   return pIdx;
 }
 /*
 ** Load the content from either the sqlite_stat4 or sqlite_stat3 table
 ** into the relevant Index.aSample[] arrays.
 **

@@ -82744,14 +83765,14 @@ static int loadStatTbl(

     zIndex = (char *)sqlite3_column_text(pStmt, 0);
     if( zIndex==0 ) continue;
     nSample = sqlite3_column_int(pStmt, 1);
     pIdx = sqlite3FindIndex(db, zIndex, zDb);
     pIdx = findIndexOrPrimaryKey(db, zIndex, zDb);
     assert( pIdx==0 || bStat3 || pIdx->nSample==0 );
     /* Index.nSample is non-zero at this point if data has already been
     ** loaded from the stat4 table. In this case ignore stat3 data.  */
     if( pIdx==0 || pIdx->nSample ) continue;
     if( bStat3==0 ){
       nIdxCol = pIdx->nColumn+1;
       nAvgCol = pIdx->nColumn;
       nIdxCol = pIdx->nKeyCol+1;
       nAvgCol = pIdx->nKeyCol;
     }
     pIdx->nSampleCol = nIdxCol;
     nByte = sizeof(IndexSample) * nSample;

@@ -82790,7 +83811,7 @@ static int loadStatTbl(

     zIndex = (char *)sqlite3_column_text(pStmt, 0);
     if( zIndex==0 ) continue;
     pIdx = sqlite3FindIndex(db, zIndex, zDb);
     pIdx = findIndexOrPrimaryKey(db, zIndex, zDb);
     if( pIdx==0 ) continue;
     /* This next condition is true if data has already been loaded from
     ** the sqlite_stat4 table. In this case ignore stat3 data.  */

@@ -82971,10 +83992,6 @@ static int resolveAttachExpr(NameContext *pName, Expr *pExpr)

   if( pExpr ){
     if( pExpr->op!=TK_ID ){
       rc = sqlite3ResolveExprNames(pName, pExpr);
       if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){
         sqlite3ErrorMsg(pName->pParse, "invalid name: \"%s\"", pExpr->u.zToken);
         return SQLITE_ERROR;
       }
     }else{
       pExpr->op = TK_STRING;
     }

@@ -83904,6 +84921,7 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){

   assert( !pParse->isMultiWrite
        || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
   if( v ){
     while( sqlite3VdbeDeletePriorOpcode(v, OP_Close) ){}
     sqlite3VdbeAddOp0(v, OP_Halt);
     /* The cookie mask contains one bit for each database file open.

@@ -83912,30 +84930,29 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){

     ** transaction on each used database and to verify the schema cookie
     ** on each used database.
     */
     if( pParse->cookieGoto>0 ){
     if( db->mallocFailed==0 && (pParse->cookieMask || pParse->pConstExpr) ){
       yDbMask mask;
       int iDb;
       sqlite3VdbeJumpHere(v, pParse->cookieGoto-1);
       int iDb, i;
       assert( sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
       sqlite3VdbeJumpHere(v, 0);
       for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){
         if( (mask & pParse->cookieMask)==0 ) continue;
         sqlite3VdbeUsesBtree(v, iDb);
         sqlite3VdbeAddOp2(v,OP_Transaction, iDb, (mask & pParse->writeMask)!=0);
         if( db->init.busy==0 ){
           assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
           sqlite3VdbeAddOp3(v, OP_VerifyCookie,
                             iDb, pParse->cookieValue[iDb],
                             db->aDb[iDb].pSchema->iGeneration);
         }
         sqlite3VdbeAddOp4Int(v,
           OP_Transaction,                    /* Opcode */
           iDb,                               /* P1 */
           (mask & pParse->writeMask)!=0,     /* P2 */
           pParse->cookieValue[iDb],          /* P3 */
           db->aDb[iDb].pSchema->iGeneration  /* P4 */
         );
         if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
       }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
       {
         int i;
         for(i=0; i<pParse->nVtabLock; i++){
           char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
           sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
         }
         pParse->nVtabLock = 0;
       for(i=0; i<pParse->nVtabLock; i++){
         char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
         sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
       }
       pParse->nVtabLock = 0;
 #endif
       /* Once all the cookies have been verified and transactions opened,

@@ -83948,8 +84965,17 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){

       */
       sqlite3AutoincrementBegin(pParse);
       /* Code constant expressions that where factored out of inner loops */
       if( pParse->pConstExpr ){
         ExprList *pEL = pParse->pConstExpr;
         pParse->okConstFactor = 0;
         for(i=0; i<pEL->nExpr; i++){
           sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
         }
       }
       /* Finally, jump back to the beginning of the executable code. */
       sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->cookieGoto);
       sqlite3VdbeAddOp2(v, OP_Goto, 0, 1);
     }
   }

@@ -83957,10 +84983,6 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){

   /* Get the VDBE program ready for execution
   */
   if( v && ALWAYS(pParse->nErr==0) && !db->mallocFailed ){
 #ifdef SQLITE_DEBUG
     FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;
     sqlite3VdbeTrace(v, trace);
 #endif
     assert( pParse->iCacheLevel==0 );  /* Disables and re-enables match */
     /* A minimum of one cursor is required if autoincrement is used
     *  See ticket [a696379c1f08866] */

@@ -83976,7 +84998,6 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){

   pParse->nSet = 0;
   pParse->nVar = 0;
   pParse->cookieMask = 0;
   pParse->cookieGoto = 0;
 }
 /*

@@ -84146,8 +85167,10 @@ static void freeIndex(sqlite3 *db, Index *p){

 #ifndef SQLITE_OMIT_ANALYZE
   sqlite3DeleteIndexSamples(db, p);
 #endif
   if( db==0 || db->pnBytesFreed==0 ) sqlite3KeyInfoUnref(p->pKeyInfo);
   sqlite3ExprDelete(db, p->pPartIdxWhere);
   sqlite3DbFree(db, p->zColAff);
   if( p->isResized ) sqlite3DbFree(db, p->azColl);
   sqlite3DbFree(db, p);
 }

@@ -84405,8 +85428,7 @@ SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, Token *pName){

 SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *p, int iDb){
   Vdbe *v = sqlite3GetVdbe(p);
   sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
   sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb);
   sqlite3VdbeChangeP4(v, -1, (char *)5, P4_INT32);  /* 5 column table */
   sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, MASTER_ROOT, iDb, 5);
   if( p->nTab==0 ){
     p->nTab = 1;
   }

@@ -84512,6 +85534,27 @@ SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *pParse, const char *zName){

 }
 /*
 ** Return the PRIMARY KEY index of a table
 */
 SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table *pTab){
   Index *p;
   for(p=pTab->pIndex; p && p->autoIndex!=2; p=p->pNext){}
   return p;
 }
 /*
 ** Return the column of index pIdx that corresponds to table
 ** column iCol.  Return -1 if not found.
 */
 SQLITE_PRIVATE i16 sqlite3ColumnOfIndex(Index *pIdx, i16 iCol){
   int i;
   for(i=0; i<pIdx->nColumn; i++){
     if( iCol==pIdx->aiColumn[i] ) return i;
   }
   return -1;
 }
 /*
 ** Begin constructing a new table representation in memory.  This is
 ** the first of several action routines that get called in response
 ** to a CREATE TABLE statement.  In particular, this routine is called

@@ -84686,7 +85729,7 @@ SQLITE_PRIVATE void sqlite3StartTable(

     reg3 = ++pParse->nMem;
     sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
     sqlite3VdbeUsesBtree(v, iDb);
     j1 = sqlite3VdbeAddOp1(v, OP_If, reg3);
     j1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
     fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
 : SQLITE_MAX_FILE_FORMAT;
     sqlite3VdbeAddOp2(v, OP_Integer, fileFormat, reg3);

@@ -84710,7 +85753,7 @@ SQLITE_PRIVATE void sqlite3StartTable(

     }else
 #endif
     {
       sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
       pParse->addrCrTab = sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
     }
     sqlite3OpenMasterTable(pParse, iDb);
     sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);

@@ -84978,6 +86021,7 @@ SQLITE_PRIVATE void sqlite3AddPrimaryKey(

   Table *pTab = pParse->pNewTable;
   char *zType = 0;
   int iCol = -1, i;
   int nTerm;
   if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit;
   if( pTab->tabFlags & TF_HasPrimaryKey ){
     sqlite3ErrorMsg(pParse,

@@ -84988,39 +86032,43 @@ SQLITE_PRIVATE void sqlite3AddPrimaryKey(

   if( pList==0 ){
     iCol = pTab->nCol - 1;
     pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY;
     zType = pTab->aCol[iCol].zType;
     nTerm = 1;
   }else{
     for(i=0; i<pList->nExpr; i++){
     nTerm = pList->nExpr;
     for(i=0; i<nTerm; i++){
       for(iCol=0; iCol<pTab->nCol; iCol++){
         if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
           pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY;
           zType = pTab->aCol[iCol].zType;
           break;
         }
       }
       if( iCol<pTab->nCol ){
         pTab->aCol[iCol].colFlags |= COLFLAG_PRIMKEY;
       }
     }
     if( pList->nExpr>1 ) iCol = -1;
   }
   if( iCol>=0 && iCol<pTab->nCol ){
     zType = pTab->aCol[iCol].zType;
   }
   if( zType && sqlite3StrICmp(zType, "INTEGER")==0
         && sortOrder==SQLITE_SO_ASC ){
   if( nTerm==1
    && zType && sqlite3StrICmp(zType, "INTEGER")==0
    && sortOrder==SQLITE_SO_ASC
   ){
     pTab->iPKey = iCol;
     pTab->keyConf = (u8)onError;
     assert( autoInc==0 || autoInc==1 );
     pTab->tabFlags |= autoInc*TF_Autoincrement;
     if( pList ) pParse->iPkSortOrder = pList->a[0].sortOrder;
   }else if( autoInc ){
 #ifndef SQLITE_OMIT_AUTOINCREMENT
     sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
        "INTEGER PRIMARY KEY");
 #endif
   }else{
     Vdbe *v = pParse->pVdbe;
     Index *p;
     if( v ) pParse->addrSkipPK = sqlite3VdbeAddOp0(v, OP_Noop);
     p = sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
 , sortOrder, 0);
     if( p ){
       p->autoIndex = 2;
       if( v ) sqlite3VdbeJumpHere(v, pParse->addrSkipPK);
     }
     pList = 0;
   }

@@ -85077,7 +86125,7 @@ SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){

     ** collation type was added. Correct this if it is the case.
     */
     for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
       assert( pIdx->nColumn==1 );
       assert( pIdx->nKeyCol==1 );
       if( pIdx->aiColumn[0]==i ){
         pIdx->azColl[0] = p->aCol[i].zColl;
       }

@@ -85185,10 +86233,10 @@ static void identPut(char *z, int *pIdx, char *zSignedIdent){

   for(j=0; zIdent[j]; j++){
     if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
   }
   needQuote = sqlite3Isdigit(zIdent[0]) || sqlite3KeywordCode(zIdent, j)!=TK_ID;
   if( !needQuote ){
     needQuote = zIdent[j];
   }
   needQuote = sqlite3Isdigit(zIdent[0])
             || sqlite3KeywordCode(zIdent, j)!=TK_ID
             || zIdent[j]!=0
             || j==0;
   if( needQuote ) z[i++] = '"';
   for(j=0; zIdent[j]; j++){

@@ -85270,6 +86318,31 @@ static char *createTableStmt(sqlite3 *db, Table *p){

 }
 /*
 ** Resize an Index object to hold N columns total.  Return SQLITE_OK
 ** on success and SQLITE_NOMEM on an OOM error.
 */
 static int resizeIndexObject(sqlite3 *db, Index *pIdx, int N){
   char *zExtra;
   int nByte;
   if( pIdx->nColumn>=N ) return SQLITE_OK;
   assert( pIdx->isResized==0 );
   nByte = (sizeof(char*) + sizeof(i16) + 1)*N;
   zExtra = sqlite3DbMallocZero(db, nByte);
   if( zExtra==0 ) return SQLITE_NOMEM;
   memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
   pIdx->azColl = (char**)zExtra;
   zExtra += sizeof(char*)*N;
   memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
   pIdx->aiColumn = (i16*)zExtra;
   zExtra += sizeof(i16)*N;
   memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
   pIdx->aSortOrder = (u8*)zExtra;
   pIdx->nColumn = N;
   pIdx->isResized = 1;
   return SQLITE_OK;
 }
 /*
 ** Estimate the total row width for a table.
 */
 static void estimateTableWidth(Table *pTab){

@@ -85287,16 +86360,148 @@ static void estimateTableWidth(Table *pTab){

 ** Estimate the average size of a row for an index.
 */
 static void estimateIndexWidth(Index *pIdx){
   unsigned wIndex = 1;
   unsigned wIndex = 0;
   int i;
   const Column *aCol = pIdx->pTable->aCol;
   for(i=0; i<pIdx->nColumn; i++){
     assert( pIdx->aiColumn[i]>=0 && pIdx->aiColumn[i]<pIdx->pTable->nCol );
     wIndex += aCol[pIdx->aiColumn[i]].szEst;
     i16 x = pIdx->aiColumn[i];
     assert( x<pIdx->pTable->nCol );
     wIndex += x<0 ? 1 : aCol[pIdx->aiColumn[i]].szEst;
   }
   pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
 }
 /* Return true if value x is found any of the first nCol entries of aiCol[]
 */
 static int hasColumn(const i16 *aiCol, int nCol, int x){
   while( nCol-- > 0 ) if( x==*(aiCol++) ) return 1;
   return 0;
 }
 /*
 ** This routine runs at the end of parsing a CREATE TABLE statement that
 ** has a WITHOUT ROWID clause.  The job of this routine is to convert both
 ** internal schema data structures and the generated VDBE code so that they
 ** are appropriate for a WITHOUT ROWID table instead of a rowid table.
 ** Changes include:
 **
 **     (1)  Convert the OP_CreateTable into an OP_CreateIndex.  There is
 **          no rowid btree for a WITHOUT ROWID.  Instead, the canonical
 **          data storage is a covering index btree.
 **     (2)  Bypass the creation of the sqlite_master table entry
 **          for the PRIMARY KEY as the the primary key index is now
 **          identified by the sqlite_master table entry of the table itself.
 **     (3)  Set the Index.tnum of the PRIMARY KEY Index object in the
 **          schema to the rootpage from the main table.
 **     (4)  Set all columns of the PRIMARY KEY schema object to be NOT NULL.
 **     (5)  Add all table columns to the PRIMARY KEY Index object
 **          so that the PRIMARY KEY is a covering index.  The surplus
 **          columns are part of KeyInfo.nXField and are not used for
 **          sorting or lookup or uniqueness checks.
 **     (6)  Replace the rowid tail on all automatically generated UNIQUE
 **          indices with the PRIMARY KEY columns.
 */
 static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
   Index *pIdx;
   Index *pPk;
   int nPk;
   int i, j;
   sqlite3 *db = pParse->db;
   Vdbe *v = pParse->pVdbe;
   /* Convert the OP_CreateTable opcode that would normally create the
   ** root-page for the table into a OP_CreateIndex opcode.  The index
   ** created will become the PRIMARY KEY index.
   */
   if( pParse->addrCrTab ){
     assert( v );
     sqlite3VdbeGetOp(v, pParse->addrCrTab)->opcode = OP_CreateIndex;
   }
   /* Bypass the creation of the PRIMARY KEY btree and the sqlite_master
   ** table entry.
   */
   if( pParse->addrSkipPK ){
     assert( v );
     sqlite3VdbeGetOp(v, pParse->addrSkipPK)->opcode = OP_Goto;
   }
   /* Locate the PRIMARY KEY index.  Or, if this table was originally
   ** an INTEGER PRIMARY KEY table, create a new PRIMARY KEY index.
   */
   if( pTab->iPKey>=0 ){
     ExprList *pList;
     pList = sqlite3ExprListAppend(pParse, 0, 0);
     if( pList==0 ) return;
     pList->a[0].zName = sqlite3DbStrDup(pParse->db,
                                         pTab->aCol[pTab->iPKey].zName);
     pList->a[0].sortOrder = pParse->iPkSortOrder;
     assert( pParse->pNewTable==pTab );
     pPk = sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0);
     if( pPk==0 ) return;
     pPk->autoIndex = 2;
     pTab->iPKey = -1;
   }else{
     pPk = sqlite3PrimaryKeyIndex(pTab);
   }
   pPk->isCovering = 1;
   assert( pPk!=0 );
   nPk = pPk->nKeyCol;
   /* Make sure every column of the PRIMARY KEY is NOT NULL */
   for(i=0; i<nPk; i++){
     pTab->aCol[pPk->aiColumn[i]].notNull = 1;
   }
   pPk->uniqNotNull = 1;
   /* The root page of the PRIMARY KEY is the table root page */
   pPk->tnum = pTab->tnum;
   /* Update the in-memory representation of all UNIQUE indices by converting
   ** the final rowid column into one or more columns of the PRIMARY KEY.
   */
   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
     int n;
     if( pIdx->autoIndex==2 ) continue;
     for(i=n=0; i<nPk; i++){
       if( !hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ) n++;
     }
     if( n==0 ){
       /* This index is a superset of the primary key */
       pIdx->nColumn = pIdx->nKeyCol;
       continue;
     }
     if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
     for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
       if( !hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ){
         pIdx->aiColumn[j] = pPk->aiColumn[i];
         pIdx->azColl[j] = pPk->azColl[i];
         j++;
       }
     }
     assert( pIdx->nColumn>=pIdx->nKeyCol+n );
     assert( pIdx->nColumn>=j );
   }
   /* Add all table columns to the PRIMARY KEY index
   */
   if( nPk<pTab->nCol ){
     if( resizeIndexObject(db, pPk, pTab->nCol) ) return;
     for(i=0, j=nPk; i<pTab->nCol; i++){
       if( !hasColumn(pPk->aiColumn, j, i) ){
         assert( j<pPk->nColumn );
         pPk->aiColumn[j] = i;
         pPk->azColl[j] = "BINARY";
         j++;
       }
     }
     assert( pPk->nColumn==j );
     assert( pTab->nCol==j );
   }else{
     pPk->nColumn = pTab->nCol;
   }
 }
 /*
 ** This routine is called to report the final ")" that terminates
 ** a CREATE TABLE statement.

@@ -85320,7 +86525,8 @@ static void estimateIndexWidth(Index *pIdx){

 SQLITE_PRIVATE void sqlite3EndTable(
   Parse *pParse,          /* Parse context */
   Token *pCons,           /* The ',' token after the last column defn. */
   Token *pEnd,            /* The final ')' token in the CREATE TABLE */
   Token *pEnd,            /* The ')' before options in the CREATE TABLE */
   u8 tabOpts,             /* Extra table options. Usually 0. */
   Select *pSelect         /* Select from a "CREATE ... AS SELECT" */
 ){
   Table *p;                 /* The new table */

@@ -85336,6 +86542,31 @@ SQLITE_PRIVATE void sqlite3EndTable(

   assert( !db->init.busy || !pSelect );
   /* If the db->init.busy is 1 it means we are reading the SQL off the
   ** "sqlite_master" or "sqlite_temp_master" table on the disk.
   ** So do not write to the disk again.  Extract the root page number
   ** for the table from the db->init.newTnum field.  (The page number
   ** should have been put there by the sqliteOpenCb routine.)
   */
   if( db->init.busy ){
     p->tnum = db->init.newTnum;
   }
   /* Special processing for WITHOUT ROWID Tables */
   if( tabOpts & TF_WithoutRowid ){
     if( (p->tabFlags & TF_Autoincrement) ){
       sqlite3ErrorMsg(pParse,
           "AUTOINCREMENT not allowed on WITHOUT ROWID tables");
       return;
     }
     if( (p->tabFlags & TF_HasPrimaryKey)==0 ){
       sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
     }else{
       p->tabFlags |= TF_WithoutRowid;
       convertToWithoutRowidTable(pParse, p);
     }
   }
   iDb = sqlite3SchemaToIndex(db, p->pSchema);
 #ifndef SQLITE_OMIT_CHECK

@@ -85352,16 +86583,6 @@ SQLITE_PRIVATE void sqlite3EndTable(

     estimateIndexWidth(pIdx);
   }
   /* If the db->init.busy is 1 it means we are reading the SQL off the
   ** "sqlite_master" or "sqlite_temp_master" table on the disk.
   ** So do not write to the disk again.  Extract the root page number
   ** for the table from the db->init.newTnum field.  (The page number
   ** should have been put there by the sqliteOpenCb routine.)
   */
   if( db->init.busy ){
     p->tnum = db->init.newTnum;
   }
   /* If not initializing, then create a record for the new table
   ** in the SQLITE_MASTER table of the database.
   **

@@ -85435,7 +86656,9 @@ SQLITE_PRIVATE void sqlite3EndTable(

     if( pSelect ){
       zStmt = createTableStmt(db, p);
     }else{
       n = (int)(pEnd->z - pParse->sNameToken.z) + 1;
       Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
       n = (int)(pEnd2->z - pParse->sNameToken.z);
       if( pEnd2->z[0]!=';' ) n += pEnd2->n;
       zStmt = sqlite3MPrintf(db,
           "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
       );

@@ -85478,7 +86701,7 @@ SQLITE_PRIVATE void sqlite3EndTable(

     /* Reparse everything to update our internal data structures */
     sqlite3VdbeAddParseSchemaOp(v, iDb,
                sqlite3MPrintf(db, "tbl_name='%q'", p->zName));
            sqlite3MPrintf(db, "tbl_name='%q' AND type!='trigger'", p->zName));
   }

@@ -85583,7 +86806,7 @@ SQLITE_PRIVATE void sqlite3CreateView(

   sEnd.n = 1;
   /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
   sqlite3EndTable(pParse, 0, &sEnd, 0);
   sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
   return;
 }
 #endif /* SQLITE_OMIT_VIEW */

@@ -86038,8 +87261,8 @@ exit_drop_table:

 ** currently under construction.  pFromCol determines which columns
 ** in the current table point to the foreign key.  If pFromCol==0 then
 ** connect the key to the last column inserted.  pTo is the name of
 ** the table referred to.  pToCol is a list of tables in the other
 ** pTo table that the foreign key points to.  flags contains all
 ** the table referred to (a.k.a the "parent" table).  pToCol is a list
 ** of tables in the parent pTo table.  flags contains all
 ** information about the conflict resolution algorithms specified
 ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
 **

@@ -86222,37 +87445,39 @@ static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){

     tnum = memRootPage;
   }else{
     tnum = pIndex->tnum;
     sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
   }
   pKey = sqlite3IndexKeyinfo(pParse, pIndex);
   sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
                     (char *)pKey, P4_KEYINFO_HANDOFF);
   sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
   pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
   /* Open the sorter cursor if we are to use one. */
   iSorter = pParse->nTab++;
   sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, 0, (char*)pKey, P4_KEYINFO);
   sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, 0, (char*)
                     sqlite3KeyInfoRef(pKey), P4_KEYINFO);
   /* Open the table. Loop through all rows of the table, inserting index
   ** records into the sorter. */
   sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
   addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0);
   addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
   regRecord = sqlite3GetTempReg(pParse);
   sqlite3GenerateIndexKey(pParse, pIndex, iTab, regRecord, 1, &iPartIdxLabel);
   sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
   sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
   sqlite3VdbeResolveLabel(v, iPartIdxLabel);
   sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1);
   sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
   sqlite3VdbeJumpHere(v, addr1);
   addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0);
   if( pIndex->onError!=OE_None ){
   if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
   sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
                     (char *)pKey, P4_KEYINFO);
   sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
   addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
   assert( pKey!=0 || db->mallocFailed || pParse->nErr );
   if( pIndex->onError!=OE_None && pKey!=0 ){
     int j2 = sqlite3VdbeCurrentAddr(v) + 3;
     sqlite3VdbeAddOp2(v, OP_Goto, 0, j2);
     addr2 = sqlite3VdbeCurrentAddr(v);
     sqlite3VdbeAddOp3(v, OP_SorterCompare, iSorter, j2, regRecord);
     sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_UNIQUE,
         OE_Abort, "indexed columns are not unique", P4_STATIC
     );
     sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
                          pKey->nField - pIndex->nKeyCol); VdbeCoverage(v);
     sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
   }else{
     addr2 = sqlite3VdbeCurrentAddr(v);
   }

@@ -86260,7 +87485,7 @@ static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){

   sqlite3VdbeAddOp3(v, OP_IdxInsert, iIdx, regRecord, 1);
   sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
   sqlite3ReleaseTempReg(pParse, regRecord);
   sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2);
   sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
   sqlite3VdbeJumpHere(v, addr1);
   sqlite3VdbeAddOp1(v, OP_Close, iTab);

@@ -86269,6 +87494,41 @@ static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){

 }
 /*
 ** Allocate heap space to hold an Index object with nCol columns.
 **
 ** Increase the allocation size to provide an extra nExtra bytes
 ** of 8-byte aligned space after the Index object and return a
 ** pointer to this extra space in *ppExtra.
 */
 SQLITE_PRIVATE Index *sqlite3AllocateIndexObject(
   sqlite3 *db,         /* Database connection */
   i16 nCol,            /* Total number of columns in the index */
   int nExtra,          /* Number of bytes of extra space to alloc */
   char **ppExtra       /* Pointer to the "extra" space */
 ){
   Index *p;            /* Allocated index object */
   int nByte;           /* Bytes of space for Index object + arrays */
   nByte = ROUND8(sizeof(Index)) +              /* Index structure  */
           ROUND8(sizeof(char*)*nCol) +         /* Index.azColl     */
           ROUND8(sizeof(tRowcnt)*(nCol+1) +    /* Index.aiRowEst   */
                  sizeof(i16)*nCol +            /* Index.aiColumn   */
                  sizeof(u8)*nCol);             /* Index.aSortOrder */
   p = sqlite3DbMallocZero(db, nByte + nExtra);
   if( p ){
     char *pExtra = ((char*)p)+ROUND8(sizeof(Index));
     p->azColl = (char**)pExtra;      pExtra += ROUND8(sizeof(char*)*nCol);
     p->aiRowEst = (tRowcnt*)pExtra;  pExtra += sizeof(tRowcnt)*(nCol+1);
     p->aiColumn = (i16*)pExtra;      pExtra += sizeof(i16)*nCol;
     p->aSortOrder = (u8*)pExtra;
     p->nColumn = nCol;
     p->nKeyCol = nCol - 1;
     *ppExtra = ((char*)p) + nByte;
   }
   return p;
 }
 /*
 ** Create a new index for an SQL table.  pName1.pName2 is the name of the index
 ** and pTblList is the name of the table that is to be indexed.  Both will
 ** be NULL for a primary key or an index that is created to satisfy a

@@ -86302,7 +87562,6 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

   char *zName = 0;     /* Name of the index */
   int nName;           /* Number of characters in zName */
   int i, j;
   Token nullId;        /* Fake token for an empty ID list */
   DbFixer sFix;        /* For assigning database names to pTable */
   int sortOrderMask;   /* 1 to honor DESC in index.  0 to ignore. */
   sqlite3 *db = pParse->db;

@@ -86311,9 +87570,10 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

   Token *pName = 0;    /* Unqualified name of the index to create */
   struct ExprList_item *pListItem; /* For looping over pList */
   const Column *pTabCol;           /* A column in the table */
   int nCol;                        /* Number of columns */
   int nExtra = 0;                  /* Space allocated for zExtra[] */
   char *zExtra;                    /* Extra space after the Index object */
   int nExtraCol;                   /* Number of extra columns needed */
   char *zExtra = 0;                /* Extra space after the Index object */
   Index *pPk = 0;      /* PRIMARY KEY index for WITHOUT ROWID tables */
   assert( pParse->nErr==0 );      /* Never called with prior errors */
   if( db->mallocFailed || IN_DECLARE_VTAB ){

@@ -86365,6 +87625,7 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

            pTab->zName);
       goto exit_create_index;
     }
     if( !HasRowid(pTab) ) pPk = sqlite3PrimaryKeyIndex(pTab);
   }else{
     assert( pName==0 );
     assert( pStart==0 );

@@ -86460,11 +87721,10 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

   ** So create a fake list to simulate this.
   */
   if( pList==0 ){
     nullId.z = pTab->aCol[pTab->nCol-1].zName;
     nullId.n = sqlite3Strlen30((char*)nullId.z);
     pList = sqlite3ExprListAppend(pParse, 0, 0);
     if( pList==0 ) goto exit_create_index;
     sqlite3ExprListSetName(pParse, pList, &nullId, 0);
     pList->a[0].zName = sqlite3DbStrDup(pParse->db,
                                         pTab->aCol[pTab->nCol-1].zName);
     pList->a[0].sortOrder = (u8)sortOrder;
   }

@@ -86483,36 +87743,23 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

   ** Allocate the index structure.
   */
   nName = sqlite3Strlen30(zName);
   nCol = pList->nExpr;
   pIndex = sqlite3DbMallocZero(db,
       ROUND8(sizeof(Index)) +              /* Index structure  */
       ROUND8(sizeof(tRowcnt)*(nCol+1)) +   /* Index.aiRowEst   */
       sizeof(char *)*nCol +                /* Index.azColl     */
       sizeof(int)*nCol +                   /* Index.aiColumn   */
       sizeof(u8)*nCol +                    /* Index.aSortOrder */
       nName + 1 +                          /* Index.zName      */
       nExtra                               /* Collation sequence names */
   );
   nExtraCol = pPk ? pPk->nKeyCol : 1;
   pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
                                       nName + nExtra + 1, &zExtra);
   if( db->mallocFailed ){
     goto exit_create_index;
   }
   zExtra = (char*)pIndex;
   pIndex->aiRowEst = (tRowcnt*)&zExtra[ROUND8(sizeof(Index))];
   pIndex->azColl = (char**)
      ((char*)pIndex->aiRowEst + ROUND8(sizeof(tRowcnt)*nCol+1));
   assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowEst) );
   assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
   pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
   pIndex->aSortOrder = (u8 *)(&pIndex->aiColumn[nCol]);
   pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
   zExtra = (char *)(&pIndex->zName[nName+1]);
   pIndex->zName = zExtra;
   zExtra += nName + 1;
   memcpy(pIndex->zName, zName, nName+1);
   pIndex->pTable = pTab;
   pIndex->nColumn = pList->nExpr;
   pIndex->onError = (u8)onError;
   pIndex->uniqNotNull = onError==OE_Abort;
   pIndex->uniqNotNull = onError!=OE_None;
   pIndex->autoIndex = (u8)(pName==0);
   pIndex->pSchema = db->aDb[iDb].pSchema;
   pIndex->nKeyCol = pList->nExpr;
   if( pPIWhere ){
     sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
     pIndex->pPartIdxWhere = pPIWhere;

@@ -86552,7 +87799,8 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

       pParse->checkSchema = 1;
       goto exit_create_index;
     }
     pIndex->aiColumn[i] = j;
     assert( pTab->nCol<=0x7fff && j<=0x7fff );
     pIndex->aiColumn[i] = (i16)j;
     if( pListItem->pExpr ){
       int nColl;
       assert( pListItem->pExpr->op==TK_COLLATE );

@@ -86575,6 +87823,23 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

     pIndex->aSortOrder[i] = (u8)requestedSortOrder;
     if( pTab->aCol[j].notNull==0 ) pIndex->uniqNotNull = 0;
   }
   if( pPk ){
     for(j=0; j<pPk->nKeyCol; j++){
       int x = pPk->aiColumn[j];
       if( hasColumn(pIndex->aiColumn, pIndex->nKeyCol, x) ){
         pIndex->nColumn--;
       }else{
         pIndex->aiColumn[i] = x;
         pIndex->azColl[i] = pPk->azColl[j];
         pIndex->aSortOrder[i] = pPk->aSortOrder[j];
         i++;
       }
     }
     assert( i==pIndex->nColumn );
   }else{
     pIndex->aiColumn[i] = -1;
     pIndex->azColl[i] = "BINARY";
   }
   sqlite3DefaultRowEst(pIndex);
   if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);

@@ -86607,8 +87872,8 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

       assert( pIdx->autoIndex );
       assert( pIndex->onError!=OE_None );
       if( pIdx->nColumn!=pIndex->nColumn ) continue;
       for(k=0; k<pIdx->nColumn; k++){
       if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
       for(k=0; k<pIdx->nKeyCol; k++){
         const char *z1;
         const char *z2;
         if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;

@@ -86616,7 +87881,7 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

         z2 = pIndex->azColl[k];
         if( z1!=z2 && sqlite3StrICmp(z1, z2) ) break;
       }
       if( k==pIdx->nColumn ){
       if( k==pIdx->nKeyCol ){
         if( pIdx->onError!=pIndex->onError ){
           /* This constraint creates the same index as a previous
           ** constraint specified somewhere in the CREATE TABLE statement.

@@ -86658,22 +87923,20 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

     }
   }
   /* If the db->init.busy is 0 then create the index on disk.  This
   ** involves writing the index into the master table and filling in the
   ** index with the current table contents.
   /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
   ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
   ** emit code to allocate the index rootpage on disk and make an entry for
   ** the index in the sqlite_master table and populate the index with
   ** content.  But, do not do this if we are simply reading the sqlite_master
   ** table to parse the schema, or if this index is the PRIMARY KEY index
   ** of a WITHOUT ROWID table.
   **
   ** The db->init.busy is 0 when the user first enters a CREATE INDEX
   ** command.  db->init.busy is 1 when a database is opened and
   ** CREATE INDEX statements are read out of the master table.  In
   ** the latter case the index already exists on disk, which is why
   ** we don't want to recreate it.
   **
   ** If pTblName==0 it means this index is generated as a primary key
   ** or UNIQUE constraint of a CREATE TABLE statement.  Since the table
   ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
   ** or UNIQUE index in a CREATE TABLE statement.  Since the table
   ** has just been created, it contains no data and the index initialization
   ** step can be skipped.
   */
   else if( pParse->nErr==0 ){
   else if( pParse->nErr==0 && (HasRowid(pTab) || pTblName!=0) ){
     Vdbe *v;
     char *zStmt;
     int iMem = ++pParse->nMem;

@@ -86785,12 +88048,12 @@ SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){

   a[0] = pIdx->pTable->nRowEst;
   if( a[0]<10 ) a[0] = 10;
   n = 10;
   for(i=1; i<=pIdx->nColumn; i++){
   for(i=1; i<=pIdx->nKeyCol; i++){
     a[i] = n;
     if( n>5 ) n--;
   }
   if( pIdx->onError!=OE_None ){
     a[pIdx->nColumn] = 1;
     a[pIdx->nKeyCol] = 1;
   }
 }

@@ -86991,7 +88254,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(

   assert( iStart<=pSrc->nSrc );
   /* Allocate additional space if needed */
   if( pSrc->nSrc+nExtra>pSrc->nAlloc ){
   if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
     SrcList *pNew;
     int nAlloc = pSrc->nSrc+nExtra;
     int nGot;

@@ -87003,7 +88266,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(

     }
     pSrc = pNew;
     nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
     pSrc->nAlloc = (u8)nGot;
     pSrc->nAlloc = nGot;
   }
   /* Move existing slots that come after the newly inserted slots

@@ -87011,7 +88274,7 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(

   for(i=pSrc->nSrc-1; i>=iStart; i--){
     pSrc->a[i+nExtra] = pSrc->a[i];
   }
   pSrc->nSrc += (i8)nExtra;
   pSrc->nSrc += nExtra;
   /* Zero the newly allocated slots */
   memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);

@@ -87343,59 +88606,26 @@ SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){

 }
 /*
 ** Generate VDBE code that will verify the schema cookie and start
 ** a read-transaction for all named database files.
 **
 ** It is important that all schema cookies be verified and all
 ** read transactions be started before anything else happens in
 ** the VDBE program.  But this routine can be called after much other
 ** code has been generated.  So here is what we do:
 **
 ** The first time this routine is called, we code an OP_Goto that
 ** will jump to a subroutine at the end of the program.  Then we
 ** record every database that needs its schema verified in the
 ** pParse->cookieMask field.  Later, after all other code has been
 ** generated, the subroutine that does the cookie verifications and
 ** starts the transactions will be coded and the OP_Goto P2 value
 ** will be made to point to that subroutine.  The generation of the
 ** cookie verification subroutine code happens in sqlite3FinishCoding().
 **
 ** If iDb<0 then code the OP_Goto only - don't set flag to verify the
 ** schema on any databases.  This can be used to position the OP_Goto
 ** early in the code, before we know if any database tables will be used.
 ** Record the fact that the schema cookie will need to be verified
 ** for database iDb.  The code to actually verify the schema cookie
 ** will occur at the end of the top-level VDBE and will be generated
 ** later, by sqlite3FinishCoding().
 */
 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
   Parse *pToplevel = sqlite3ParseToplevel(pParse);
   sqlite3 *db = pToplevel->db;
   yDbMask mask;
 #ifndef SQLITE_OMIT_TRIGGER
   if( pToplevel!=pParse ){
     /* This branch is taken if a trigger is currently being coded. In this
     ** case, set cookieGoto to a non-zero value to show that this function
     ** has been called. This is used by the sqlite3ExprCodeConstants()
     ** function. */
     pParse->cookieGoto = -1;
   }
 #endif
   if( pToplevel->cookieGoto==0 ){
     Vdbe *v = sqlite3GetVdbe(pToplevel);
     if( v==0 ) return;  /* This only happens if there was a prior error */
     pToplevel->cookieGoto = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0)+1;
   }
   if( iDb>=0 ){
     sqlite3 *db = pToplevel->db;
     yDbMask mask;
     assert( iDb<db->nDb );
     assert( db->aDb[iDb].pBt!=0 || iDb==1 );
     assert( iDb<SQLITE_MAX_ATTACHED+2 );
     assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
     mask = ((yDbMask)1)<<iDb;
     if( (pToplevel->cookieMask & mask)==0 ){
       pToplevel->cookieMask |= mask;
       pToplevel->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
       if( !OMIT_TEMPDB && iDb==1 ){
         sqlite3OpenTempDatabase(pToplevel);
       }
   assert( iDb>=0 && iDb<db->nDb );
   assert( db->aDb[iDb].pBt!=0 || iDb==1 );
   assert( iDb<SQLITE_MAX_ATTACHED+2 );
   assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
   mask = ((yDbMask)1)<<iDb;
   if( (pToplevel->cookieMask & mask)==0 ){
     pToplevel->cookieMask |= mask;
     pToplevel->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
     if( !OMIT_TEMPDB && iDb==1 ){
       sqlite3OpenTempDatabase(pToplevel);
     }
   }
 }

@@ -87478,7 +88708,8 @@ SQLITE_PRIVATE void sqlite3HaltConstraint(

   int errCode,      /* extended error code */
   int onError,      /* Constraint type */
   char *p4,         /* Error message */
   int p4type        /* P4_STATIC or P4_TRANSIENT */
   i8 p4type,        /* P4_STATIC or P4_TRANSIENT */
   u8 p5Errmsg       /* P5_ErrMsg type */
 ){
   Vdbe *v = sqlite3GetVdbe(pParse);
   assert( (errCode&0xff)==SQLITE_CONSTRAINT );

@@ -87486,6 +88717,58 @@ SQLITE_PRIVATE void sqlite3HaltConstraint(

     sqlite3MayAbort(pParse);
   }
   sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
   if( p5Errmsg ) sqlite3VdbeChangeP5(v, p5Errmsg);
 }
 /*
 ** Code an OP_Halt due to UNIQUE or PRIMARY KEY constraint violation.
 */
 SQLITE_PRIVATE void sqlite3UniqueConstraint(
   Parse *pParse,    /* Parsing context */
   int onError,      /* Constraint type */
   Index *pIdx       /* The index that triggers the constraint */
 ){
   char *zErr;
   int j;
   StrAccum errMsg;
   Table *pTab = pIdx->pTable;
   sqlite3StrAccumInit(&errMsg, 0, 0, 200);
   errMsg.db = pParse->db;
   for(j=0; j<pIdx->nKeyCol; j++){
     char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
     if( j ) sqlite3StrAccumAppend(&errMsg, ", ", 2);
     sqlite3StrAccumAppendAll(&errMsg, pTab->zName);
     sqlite3StrAccumAppend(&errMsg, ".", 1);
     sqlite3StrAccumAppendAll(&errMsg, zCol);
   }
   zErr = sqlite3StrAccumFinish(&errMsg);
   sqlite3HaltConstraint(pParse,
     (pIdx->autoIndex==2)?SQLITE_CONSTRAINT_PRIMARYKEY:SQLITE_CONSTRAINT_UNIQUE,
     onError, zErr, P4_DYNAMIC, P5_ConstraintUnique);
 }
 /*
 ** Code an OP_Halt due to non-unique rowid.
 */
 SQLITE_PRIVATE void sqlite3RowidConstraint(
   Parse *pParse,    /* Parsing context */
   int onError,      /* Conflict resolution algorithm */
   Table *pTab       /* The table with the non-unique rowid */
 ){
   char *zMsg;
   int rc;
   if( pTab->iPKey>=0 ){
     zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
                           pTab->aCol[pTab->iPKey].zName);
     rc = SQLITE_CONSTRAINT_PRIMARYKEY;
   }else{
     zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
     rc = SQLITE_CONSTRAINT_ROWID;
   }
   sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
                         P5_ConstraintUnique);
 }
 /*

@@ -87498,8 +88781,8 @@ static int collationMatch(const char *zColl, Index *pIndex){

   assert( zColl!=0 );
   for(i=0; i<pIndex->nColumn; i++){
     const char *z = pIndex->azColl[i];
     assert( z!=0 );
     if( 0==sqlite3StrICmp(z, zColl) ){
     assert( z!=0 || pIndex->aiColumn[i]<0 );
     if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
       return 1;
     }
   }

@@ -87618,36 +88901,121 @@ SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){

 #endif
 /*
 ** Return a dynamicly allocated KeyInfo structure that can be used
 ** with OP_OpenRead or OP_OpenWrite to access database index pIdx.
 ** Return a KeyInfo structure that is appropriate for the given Index.
 **
 ** If successful, a pointer to the new structure is returned. In this case
 ** the caller is responsible for calling sqlite3DbFree(db, ) on the returned
 ** pointer. If an error occurs (out of memory or missing collation
 ** sequence), NULL is returned and the state of pParse updated to reflect
 ** the error.
 ** The KeyInfo structure for an index is cached in the Index object.
 ** So there might be multiple references to the returned pointer.  The
 ** caller should not try to modify the KeyInfo object.
 **
 ** The caller should invoke sqlite3KeyInfoUnref() on the returned object
 ** when it has finished using it.
 */
 SQLITE_PRIVATE KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){
   int i;
   int nCol = pIdx->nColumn;
   KeyInfo *pKey;
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
   if( pParse->nErr ) return 0;
 #ifndef SQLITE_OMIT_SHARED_CACHE
   if( pIdx->pKeyInfo && pIdx->pKeyInfo->db!=pParse->db ){
     sqlite3KeyInfoUnref(pIdx->pKeyInfo);
     pIdx->pKeyInfo = 0;
   }
 #endif
   if( pIdx->pKeyInfo==0 ){
     int i;
     int nCol = pIdx->nColumn;
     int nKey = pIdx->nKeyCol;
     KeyInfo *pKey;
     if( pIdx->uniqNotNull ){
       pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
     }else{
       pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
     }
     if( pKey ){
       assert( sqlite3KeyInfoIsWriteable(pKey) );
       for(i=0; i<nCol; i++){
         char *zColl = pIdx->azColl[i];
         assert( zColl!=0 );
         pKey->aColl[i] = strcmp(zColl,"BINARY")==0 ? 0 :
                           sqlite3LocateCollSeq(pParse, zColl);
         pKey->aSortOrder[i] = pIdx->aSortOrder[i];
       }
       if( pParse->nErr ){
         sqlite3KeyInfoUnref(pKey);
       }else{
         pIdx->pKeyInfo = pKey;
       }
     }
   }
   return sqlite3KeyInfoRef(pIdx->pKeyInfo);
 }
   pKey = sqlite3KeyInfoAlloc(pParse->db, nCol);
   if( pKey ){
     for(i=0; i<nCol; i++){
       char *zColl = pIdx->azColl[i];
       assert( zColl );
       pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl);
       pKey->aSortOrder[i] = pIdx->aSortOrder[i];
 #ifndef SQLITE_OMIT_CTE
 /*
 ** This routine is invoked once per CTE by the parser while parsing a
 ** WITH clause.
 */
 SQLITE_PRIVATE With *sqlite3WithAdd(
   Parse *pParse,          /* Parsing context */
   With *pWith,            /* Existing WITH clause, or NULL */
   Token *pName,           /* Name of the common-table */
   ExprList *pArglist,     /* Optional column name list for the table */
   Select *pQuery          /* Query used to initialize the table */
 ){
   sqlite3 *db = pParse->db;
   With *pNew;
   char *zName;
   /* Check that the CTE name is unique within this WITH clause. If
   ** not, store an error in the Parse structure. */
   zName = sqlite3NameFromToken(pParse->db, pName);
   if( zName && pWith ){
     int i;
     for(i=0; i<pWith->nCte; i++){
       if( sqlite3StrICmp(zName, pWith->a[i].zName)==0 ){
         sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
       }
     }
   }
   if( pParse->nErr ){
     sqlite3DbFree(pParse->db, pKey);
     pKey = 0;
   if( pWith ){
     int nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
     pNew = sqlite3DbRealloc(db, pWith, nByte);
   }else{
     pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
   }
   assert( zName!=0 || pNew==0 );
   assert( db->mallocFailed==0 || pNew==0 );
   if( pNew==0 ){
     sqlite3ExprListDelete(db, pArglist);
     sqlite3SelectDelete(db, pQuery);
     sqlite3DbFree(db, zName);
     pNew = pWith;
   }else{
     pNew->a[pNew->nCte].pSelect = pQuery;
     pNew->a[pNew->nCte].pCols = pArglist;
     pNew->a[pNew->nCte].zName = zName;
     pNew->a[pNew->nCte].zErr = 0;
     pNew->nCte++;
   }
   return pNew;
 }
 /*
 ** Free the contents of the With object passed as the second argument.
 */
 SQLITE_PRIVATE void sqlite3WithDelete(sqlite3 *db, With *pWith){
   if( pWith ){
     int i;
     for(i=0; i<pWith->nCte; i++){
       struct Cte *pCte = &pWith->a[i];
       sqlite3ExprListDelete(db, pCte->pCols);
       sqlite3SelectDelete(db, pCte->pSelect);
       sqlite3DbFree(db, pCte->zName);
     }
     sqlite3DbFree(db, pWith);
   }
   return pKey;
 }
 #endif /* !defined(SQLITE_OMIT_CTE) */
 /************** End of build.c ***********************************************/
 /************** Begin file callback.c ****************************************/

@@ -88009,7 +89377,6 @@ SQLITE_PRIVATE FuncDef *sqlite3FindFunction(

   assert( nArg>=(-2) );
   assert( nArg>=(-1) || createFlag==0 );
   assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
   h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
   /* First search for a match amongst the application-defined functions.

@@ -88229,10 +89596,8 @@ SQLITE_PRIVATE void sqlite3MaterializeView(

   SrcList *pFrom;
   sqlite3 *db = pParse->db;
   int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
   pWhere = sqlite3ExprDup(db, pWhere, 0);
   pFrom = sqlite3SrcListAppend(db, 0, 0, 0);
   if( pFrom ){
     assert( pFrom->nSrc==1 );
     pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);

@@ -88240,10 +89605,7 @@ SQLITE_PRIVATE void sqlite3MaterializeView(

     assert( pFrom->a[0].pOn==0 );
     assert( pFrom->a[0].pUsing==0 );
   }
   pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);
   if( pSel ) pSel->selFlags |= SF_Materialize;
   sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
   sqlite3Select(pParse, pSel, &dest);
   sqlite3SelectDelete(db, pSel);

@@ -88266,7 +89628,7 @@ SQLITE_PRIVATE Expr *sqlite3LimitWhere(

   ExprList *pOrderBy,          /* The ORDER BY clause.  May be null */
   Expr *pLimit,                /* The LIMIT clause.  May be null */
   Expr *pOffset,               /* The OFFSET clause.  May be null */
   char *zStmtType              /* Either DELETE or UPDATE.  For error messages. */
   char *zStmtType              /* Either DELETE or UPDATE.  For err msgs. */
 ){
   Expr *pWhereRowid = NULL;    /* WHERE rowid .. */
   Expr *pInClause = NULL;      /* WHERE rowid IN ( select ) */

@@ -88341,7 +89703,8 @@ limit_where_cleanup_2:

   sqlite3ExprDelete(pParse->db, pOffset);
   return 0;
 }
 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) */
        /*      && !defined(SQLITE_OMIT_SUBQUERY) */
 /*
 ** Generate code for a DELETE FROM statement.

@@ -88358,18 +89721,34 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(

   Vdbe *v;               /* The virtual database engine */
   Table *pTab;           /* The table from which records will be deleted */
   const char *zDb;       /* Name of database holding pTab */
   int end, addr = 0;     /* A couple addresses of generated code */
   int i;                 /* Loop counter */
   WhereInfo *pWInfo;     /* Information about the WHERE clause */
   Index *pIdx;           /* For looping over indices of the table */
   int iCur;              /* VDBE Cursor number for pTab */
   int iTabCur;           /* Cursor number for the table */
   int iDataCur;          /* VDBE cursor for the canonical data source */
   int iIdxCur;           /* Cursor number of the first index */
   int nIdx;              /* Number of indices */
   sqlite3 *db;           /* Main database structure */
   AuthContext sContext;  /* Authorization context */
   NameContext sNC;       /* Name context to resolve expressions in */
   int iDb;               /* Database number */
   int memCnt = -1;       /* Memory cell used for change counting */
   int rcauth;            /* Value returned by authorization callback */
   int okOnePass;         /* True for one-pass algorithm without the FIFO */
   int aiCurOnePass[2];   /* The write cursors opened by WHERE_ONEPASS */
   u8 *aToOpen = 0;       /* Open cursor iTabCur+j if aToOpen[j] is true */
   Index *pPk;            /* The PRIMARY KEY index on the table */
   int iPk = 0;           /* First of nPk registers holding PRIMARY KEY value */
   i16 nPk = 1;           /* Number of columns in the PRIMARY KEY */
   int iKey;              /* Memory cell holding key of row to be deleted */
   i16 nKey;              /* Number of memory cells in the row key */
   int iEphCur = 0;       /* Ephemeral table holding all primary key values */
   int iRowSet = 0;       /* Register for rowset of rows to delete */
   int addrBypass = 0;    /* Address of jump over the delete logic */
   int addrLoop = 0;      /* Top of the delete loop */
   int addrDelete = 0;    /* Jump directly to the delete logic */
   int addrEphOpen = 0;   /* Instruction to open the Ephermeral table */
 #ifndef SQLITE_OMIT_TRIGGER
   int isView;                  /* True if attempting to delete from a view */
   Trigger *pTrigger;           /* List of table triggers, if required */

@@ -88424,11 +89803,11 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(

   }
   assert(!isView || pTrigger);
   /* Assign  cursor number to the table and all its indices.
   /* Assign cursor numbers to the table and all its indices.
   */
   assert( pTabList->nSrc==1 );
   iCur = pTabList->a[0].iCursor = pParse->nTab++;
   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
   iTabCur = pTabList->a[0].iCursor = pParse->nTab++;
   for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
     pParse->nTab++;
   }

@@ -88452,7 +89831,8 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(

   */
 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
   if( isView ){
     sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
     sqlite3MaterializeView(pParse, pTab, pWhere, iTabCur);
     iDataCur = iIdxCur = iTabCur;
   }
 #endif

@@ -88483,78 +89863,170 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(

   ){
     assert( !isView );
     sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
     sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
                       pTab->zName, P4_STATIC);
     if( HasRowid(pTab) ){
       sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
                         pTab->zName, P4_STATIC);
     }
     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
       assert( pIdx->pSchema==pTab->pSchema );
       sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
     }
   }else
 #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
   /* The usual case: There is a WHERE clause so we have to scan through
   ** the table and pick which records to delete.
   */
   {
     int iRowSet = ++pParse->nMem;   /* Register for rowset of rows to delete */
     int iRowid = ++pParse->nMem;    /* Used for storing rowid values. */
     int regRowid;                   /* Actual register containing rowids */
     /* Collect rowids of every row to be deleted.
     if( HasRowid(pTab) ){
       /* For a rowid table, initialize the RowSet to an empty set */
       pPk = 0;
       nPk = 1;
       iRowSet = ++pParse->nMem;
       sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);
     }else{
       /* For a WITHOUT ROWID table, create an ephermeral table used to
       ** hold all primary keys for rows to be deleted. */
       pPk = sqlite3PrimaryKeyIndex(pTab);
       assert( pPk!=0 );
       nPk = pPk->nKeyCol;
       iPk = pParse->nMem+1;
       pParse->nMem += nPk;
       iEphCur = pParse->nTab++;
       addrEphOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEphCur, nPk);
       sqlite3VdbeSetP4KeyInfo(pParse, pPk);
     }
     /* Construct a query to find the rowid or primary key for every row
     ** to be deleted, based on the WHERE clause.
     */
     sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);
     pWInfo = sqlite3WhereBegin(
         pParse, pTabList, pWhere, 0, 0, WHERE_DUPLICATES_OK, 0
     );
     pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0,
                                WHERE_ONEPASS_DESIRED|WHERE_DUPLICATES_OK,
                                iTabCur+1);
     if( pWInfo==0 ) goto delete_from_cleanup;
     regRowid = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, iRowid, 0);
     sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, regRowid);
     okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
     /* Keep track of the number of rows to be deleted */
     if( db->flags & SQLITE_CountRows ){
       sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
     }
     /* Extract the rowid or primary key for the current row */
     if( pPk ){
       for(i=0; i<nPk; i++){
         sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
                                         pPk->aiColumn[i], iPk+i);
       }
       iKey = iPk;
     }else{
       iKey = pParse->nMem + 1;
       iKey = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iTabCur, iKey, 0);
       if( iKey>pParse->nMem ) pParse->nMem = iKey;
     }
     if( okOnePass ){
       /* For ONEPASS, no need to store the rowid/primary-key.  There is only
       ** one, so just keep it in its register(s) and fall through to the
       ** delete code.
       */
       nKey = nPk; /* OP_Found will use an unpacked key */
       aToOpen = sqlite3DbMallocRaw(db, nIdx+2);
       if( aToOpen==0 ){
         sqlite3WhereEnd(pWInfo);
         goto delete_from_cleanup;
       }
       memset(aToOpen, 1, nIdx+1);
       aToOpen[nIdx+1] = 0;
       if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iTabCur] = 0;
       if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iTabCur] = 0;
       if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen);
       addrDelete = sqlite3VdbeAddOp0(v, OP_Goto); /* Jump to DELETE logic */
     }else if( pPk ){
       /* Construct a composite key for the row to be deleted and remember it */
       iKey = ++pParse->nMem;
       nKey = 0;   /* Zero tells OP_Found to use a composite key */
       sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, iKey,
                         sqlite3IndexAffinityStr(v, pPk), nPk);
       sqlite3VdbeAddOp2(v, OP_IdxInsert, iEphCur, iKey);
     }else{
       /* Get the rowid of the row to be deleted and remember it in the RowSet */
       nKey = 1;  /* OP_Seek always uses a single rowid */
       sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey);
     }
     /* End of the WHERE loop */
     sqlite3WhereEnd(pWInfo);
     /* Delete every item whose key was written to the list during the
     ** database scan.  We have to delete items after the scan is complete
     ** because deleting an item can change the scan order.  */
     end = sqlite3VdbeMakeLabel(v);
     if( okOnePass ){
       /* Bypass the delete logic below if the WHERE loop found zero rows */
       addrBypass = sqlite3VdbeMakeLabel(v);
       sqlite3VdbeAddOp2(v, OP_Goto, 0, addrBypass);
       sqlite3VdbeJumpHere(v, addrDelete);
     }
     /* Unless this is a view, open cursors for the table we are
     ** deleting from and all its indices. If this is a view, then the
     ** only effect this statement has is to fire the INSTEAD OF
     ** triggers.  */
     ** triggers.
     */
     if( !isView ){
       sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
       sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iTabCur, aToOpen,
                                  &iDataCur, &iIdxCur);
       assert( pPk || iDataCur==iTabCur );
       assert( pPk || iIdxCur==iDataCur+1 );
     }
     addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, end, iRowid);
     /* Set up a loop over the rowids/primary-keys that were found in the
     ** where-clause loop above.
     */
     if( okOnePass ){
       /* Just one row.  Hence the top-of-loop is a no-op */
       assert( nKey==nPk ); /* OP_Found will use an unpacked key */
       if( aToOpen[iDataCur-iTabCur] ){
         assert( pPk!=0 );
         sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey);
         VdbeCoverage(v);
       }
     }else if( pPk ){
       addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v);
       sqlite3VdbeAddOp2(v, OP_RowKey, iEphCur, iKey);
       assert( nKey==0 );  /* OP_Found will use a composite key */
     }else{
       addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey);
       VdbeCoverage(v);
       assert( nKey==1 );
     }
     /* Delete the row */
 #ifndef SQLITE_OMIT_VIRTUALTABLE
     if( IsVirtual(pTab) ){
       const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
       sqlite3VtabMakeWritable(pParse, pTab);
       sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVTab, P4_VTAB);
       sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB);
       sqlite3VdbeChangeP5(v, OE_Abort);
       sqlite3MayAbort(pParse);
     }else
 #endif
     {
       int count = (pParse->nested==0);    /* True to count changes */
       sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default);
       sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
                                iKey, nKey, count, OE_Default, okOnePass);
     }
     /* End of the delete loop */
     sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
     sqlite3VdbeResolveLabel(v, end);
     /* End of the loop over all rowids/primary-keys. */
     if( okOnePass ){
       sqlite3VdbeResolveLabel(v, addrBypass);
     }else if( pPk ){
       sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v);
       sqlite3VdbeJumpHere(v, addrLoop);
     }else{
       sqlite3VdbeAddOp2(v, OP_Goto, 0, addrLoop);
       sqlite3VdbeJumpHere(v, addrLoop);
     }
     /* Close the cursors open on the table and its indexes. */
     if( !isView && !IsVirtual(pTab) ){
       for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
         sqlite3VdbeAddOp2(v, OP_Close, iCur + i, pIdx->tnum);
       if( !pPk ) sqlite3VdbeAddOp1(v, OP_Close, iDataCur);
       for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
         sqlite3VdbeAddOp1(v, OP_Close, iIdxCur + i);
       }
       sqlite3VdbeAddOp1(v, OP_Close, iCur);
     }
   }
   } /* End non-truncate path */
   /* Update the sqlite_sequence table by storing the content of the
   ** maximum rowid counter values recorded while inserting into

@@ -88578,6 +90050,7 @@ delete_from_cleanup:

   sqlite3AuthContextPop(&sContext);
   sqlite3SrcListDelete(db, pTabList);
   sqlite3ExprDelete(db, pWhere);
   sqlite3DbFree(db, aToOpen);
   return;
 }
 /* Make sure "isView" and other macros defined above are undefined. Otherwise

@@ -88592,50 +90065,63 @@ delete_from_cleanup:

 /*
 ** This routine generates VDBE code that causes a single row of a
 ** single table to be deleted.
 ** single table to be deleted.  Both the original table entry and
 ** all indices are removed.
 **
 ** The VDBE must be in a particular state when this routine is called.
 ** These are the requirements:
 ** Preconditions:
 **
 **   1.  A read/write cursor pointing to pTab, the table containing the row
 **       to be deleted, must be opened as cursor number $iCur.
 **   1.  iDataCur is an open cursor on the btree that is the canonical data
 **       store for the table.  (This will be either the table itself,
 **       in the case of a rowid table, or the PRIMARY KEY index in the case
 **       of a WITHOUT ROWID table.)
 **
 **   2.  Read/write cursors for all indices of pTab must be open as
 **       cursor number base+i for the i-th index.
 **
 **   3.  The record number of the row to be deleted must be stored in
 **       memory cell iRowid.
 **       cursor number iIdxCur+i for the i-th index.
 **
 ** This routine generates code to remove both the table record and all
 ** index entries that point to that record.
 **   3.  The primary key for the row to be deleted must be stored in a
 **       sequence of nPk memory cells starting at iPk.  If nPk==0 that means
 **       that a search record formed from OP_MakeRecord is contained in the
 **       single memory location iPk.
 */
 SQLITE_PRIVATE void sqlite3GenerateRowDelete(
   Parse *pParse,     /* Parsing context */
   Table *pTab,       /* Table containing the row to be deleted */
   int iCur,          /* Cursor number for the table */
   int iRowid,        /* Memory cell that contains the rowid to delete */
   int count,         /* If non-zero, increment the row change counter */
   Trigger *pTrigger, /* List of triggers to (potentially) fire */
   int onconf         /* Default ON CONFLICT policy for triggers */
   int iDataCur,      /* Cursor from which column data is extracted */
   int iIdxCur,       /* First index cursor */
   int iPk,           /* First memory cell containing the PRIMARY KEY */
   i16 nPk,           /* Number of PRIMARY KEY memory cells */
   u8 count,          /* If non-zero, increment the row change counter */
   u8 onconf,         /* Default ON CONFLICT policy for triggers */
   u8 bNoSeek         /* iDataCur is already pointing to the row to delete */
 ){
   Vdbe *v = pParse->pVdbe;        /* Vdbe */
   int iOld = 0;                   /* First register in OLD.* array */
   int iLabel;                     /* Label resolved to end of generated code */
   u8 opSeek;                      /* Seek opcode */
   /* Vdbe is guaranteed to have been allocated by this stage. */
   assert( v );
   VdbeModuleComment((v, "BEGIN: GenRowDel(%d,%d,%d,%d)",
                          iDataCur, iIdxCur, iPk, (int)nPk));
   /* Seek cursor iCur to the row to delete. If this row no longer exists
   ** (this can happen if a trigger program has already deleted it), do
   ** not attempt to delete it or fire any DELETE triggers.  */
   iLabel = sqlite3VdbeMakeLabel(v);
   sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
   opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
   if( !bNoSeek ){
     sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
     VdbeCoverageIf(v, opSeek==OP_NotExists);
     VdbeCoverageIf(v, opSeek==OP_NotFound);
   }
   /* If there are any triggers to fire, allocate a range of registers to
   ** use for the old.* references in the triggers.  */
   if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
     u32 mask;                     /* Mask of OLD.* columns in use */
     int iCol;                     /* Iterator used while populating OLD.* */
     int addrStart;                /* Start of BEFORE trigger programs */
     /* TODO: Could use temporary registers here. Also could attempt to
     ** avoid copying the contents of the rowid register.  */

@@ -88648,23 +90134,31 @@ SQLITE_PRIVATE void sqlite3GenerateRowDelete(

     /* Populate the OLD.* pseudo-table register array. These values will be
     ** used by any BEFORE and AFTER triggers that exist.  */
     sqlite3VdbeAddOp2(v, OP_Copy, iRowid, iOld);
     sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld);
     for(iCol=0; iCol<pTab->nCol; iCol++){
       if( mask==0xffffffff || mask&(1<<iCol) ){
         sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol, iOld+iCol+1);
       testcase( mask!=0xffffffff && iCol==31 );
       testcase( mask!=0xffffffff && iCol==32 );
       if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
         sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+iCol+1);
       }
     }
     /* Invoke BEFORE DELETE trigger programs. */
     addrStart = sqlite3VdbeCurrentAddr(v);
     sqlite3CodeRowTrigger(pParse, pTrigger,
         TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
     );
     /* Seek the cursor to the row to be deleted again. It may be that
     ** the BEFORE triggers coded above have already removed the row
     ** being deleted. Do not attempt to delete the row a second time, and
     ** do not fire AFTER triggers.  */
     sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
     /* If any BEFORE triggers were coded, then seek the cursor to the
     ** row to be deleted again. It may be that the BEFORE triggers moved
     ** the cursor or of already deleted the row that the cursor was
     ** pointing to.
     */
     if( addrStart<sqlite3VdbeCurrentAddr(v) ){
       sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
       VdbeCoverageIf(v, opSeek==OP_NotExists);
       VdbeCoverageIf(v, opSeek==OP_NotFound);
     }
     /* Do FK processing. This call checks that any FK constraints that
     ** refer to this table (i.e. constraints attached to other tables)

@@ -88676,8 +90170,8 @@ SQLITE_PRIVATE void sqlite3GenerateRowDelete(

   ** a view (in which case the only effect of the DELETE statement is to
   ** fire the INSTEAD OF triggers).  */
   if( pTab->pSelect==0 ){
     sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);
     sqlite3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));
     sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, 0);
     sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0));
     if( count ){
       sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
     }

@@ -88697,49 +90191,64 @@ SQLITE_PRIVATE void sqlite3GenerateRowDelete(

   ** trigger programs were invoked. Or if a trigger program throws a
   ** RAISE(IGNORE) exception.  */
   sqlite3VdbeResolveLabel(v, iLabel);
   VdbeModuleComment((v, "END: GenRowDel()"));
 }
 /*
 ** This routine generates VDBE code that causes the deletion of all
 ** index entries associated with a single row of a single table.
 ** index entries associated with a single row of a single table, pTab
 **
 ** The VDBE must be in a particular state when this routine is called.
 ** These are the requirements:
 ** Preconditions:
 **
 **   1.  A read/write cursor pointing to pTab, the table containing the row
 **       to be deleted, must be opened as cursor number "iCur".
 **   1.  A read/write cursor "iDataCur" must be open on the canonical storage
 **       btree for the table pTab.  (This will be either the table itself
 **       for rowid tables or to the primary key index for WITHOUT ROWID
 **       tables.)
 **
 **   2.  Read/write cursors for all indices of pTab must be open as
 **       cursor number iCur+i for the i-th index.
 **       cursor number iIdxCur+i for the i-th index.  (The pTab->pIndex
 **       index is the 0-th index.)
 **
 **   3.  The "iCur" cursor must be pointing to the row that is to be
 **       deleted.
 **   3.  The "iDataCur" cursor must be already be positioned on the row
 **       that is to be deleted.
 */
 SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(
   Parse *pParse,     /* Parsing and code generating context */
   Table *pTab,       /* Table containing the row to be deleted */
   int iCur,          /* Cursor number for the table */
   int iDataCur,      /* Cursor of table holding data. */
   int iIdxCur,       /* First index cursor */
   int *aRegIdx       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
 ){
   int i;
   Index *pIdx;
   int r1;
   int iPartIdxLabel;
   Vdbe *v = pParse->pVdbe;
   int i;             /* Index loop counter */
   int r1 = -1;       /* Register holding an index key */
   int iPartIdxLabel; /* Jump destination for skipping partial index entries */
   Index *pIdx;       /* Current index */
   Index *pPrior = 0; /* Prior index */
   Vdbe *v;           /* The prepared statement under construction */
   Index *pPk;        /* PRIMARY KEY index, or NULL for rowid tables */
   for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
     if( aRegIdx!=0 && aRegIdx[i-1]==0 ) continue;
     r1 = sqlite3GenerateIndexKey(pParse, pIdx, iCur, 0, 0, &iPartIdxLabel);
     sqlite3VdbeAddOp3(v, OP_IdxDelete, iCur+i, r1, pIdx->nColumn+1);
   v = pParse->pVdbe;
   pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
   for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
     assert( iIdxCur+i!=iDataCur || pPk==pIdx );
     if( aRegIdx!=0 && aRegIdx[i]==0 ) continue;
     if( pIdx==pPk ) continue;
     VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
     r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1,
                                  &iPartIdxLabel, pPrior, r1);
     sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1,
                       pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn);
     sqlite3VdbeResolveLabel(v, iPartIdxLabel);
     pPrior = pIdx;
   }
 }
 /*
 ** Generate code that will assemble an index key and put it in register
 ** Generate code that will assemble an index key and stores it in register
 ** regOut.  The key with be for index pIdx which is an index on pTab.
 ** iCur is the index of a cursor open on the pTab table and pointing to
 ** the entry that needs indexing.
 ** the entry that needs indexing.  If pTab is a WITHOUT ROWID table, then
 ** iCur must be the cursor of the PRIMARY KEY index.
 **
 ** Return a register number which is the first in a block of
 ** registers that holds the elements of the index key.  The

@@ -88752,14 +90261,27 @@ SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(

 ** to false or null.  If pIdx is not a partial index, *piPartIdxLabel
 ** will be set to zero which is an empty label that is ignored by
 ** sqlite3VdbeResolveLabel().
 **
 ** The pPrior and regPrior parameters are used to implement a cache to
 ** avoid unnecessary register loads.  If pPrior is not NULL, then it is
 ** a pointer to a different index for which an index key has just been
 ** computed into register regPrior.  If the current pIdx index is generating
 ** its key into the same sequence of registers and if pPrior and pIdx share
 ** a column in common, then the register corresponding to that column already
 ** holds the correct value and the loading of that register is skipped.
 ** This optimization is helpful when doing a DELETE or an INTEGRITY_CHECK
 ** on a table with multiple indices, and especially with the ROWID or
 ** PRIMARY KEY columns of the index.
 */
 SQLITE_PRIVATE int sqlite3GenerateIndexKey(
   Parse *pParse,       /* Parsing context */
   Index *pIdx,         /* The index for which to generate a key */
   int iCur,            /* Cursor number for the pIdx->pTable table */
   int regOut,          /* Write the new index key to this register */
   int doMakeRec,       /* Run the OP_MakeRecord instruction if true */
   int *piPartIdxLabel  /* OUT: Jump to this label to skip partial index */
   int iDataCur,        /* Cursor number from which to take column data */
   int regOut,          /* Put the new key into this register if not 0 */
   int prefixOnly,      /* Compute only a unique prefix of the key */
   int *piPartIdxLabel, /* OUT: Jump to this label to skip partial index */
   Index *pPrior,       /* Previously generated index key */
   int regPrior         /* Register holding previous generated key */
 ){
   Vdbe *v = pParse->pVdbe;
   int j;

@@ -88770,38 +90292,32 @@ SQLITE_PRIVATE int sqlite3GenerateIndexKey(

   if( piPartIdxLabel ){
     if( pIdx->pPartIdxWhere ){
       *piPartIdxLabel = sqlite3VdbeMakeLabel(v);
       pParse->iPartIdxTab = iCur;
       pParse->iPartIdxTab = iDataCur;
       sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,
                          SQLITE_JUMPIFNULL);
     }else{
       *piPartIdxLabel = 0;
     }
   }
   nCol = pIdx->nColumn;
   regBase = sqlite3GetTempRange(pParse, nCol+1);
   sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
   nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
   regBase = sqlite3GetTempRange(pParse, nCol);
   if( pPrior && (regBase!=regPrior || pPrior->pPartIdxWhere) ) pPrior = 0;
   for(j=0; j<nCol; j++){
     int idx = pIdx->aiColumn[j];
     if( idx==pTab->iPKey ){
       sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
     }else{
       sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);
       sqlite3ColumnDefault(v, pTab, idx, -1);
     }
   }
   if( doMakeRec ){
     const char *zAff;
     if( pTab->pSelect
      || OptimizationDisabled(pParse->db, SQLITE_IdxRealAsInt)
     ){
       zAff = 0;
     }else{
       zAff = sqlite3IndexAffinityStr(v, pIdx);
     }
     sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
     sqlite3VdbeChangeP4(v, -1, zAff, P4_TRANSIENT);
   }
   sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
     if( pPrior && pPrior->aiColumn[j]==pIdx->aiColumn[j] ) continue;
     sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pIdx->aiColumn[j],
                                     regBase+j);
     /* If the column affinity is REAL but the number is an integer, then it
     ** might be stored in the table as an integer (using a compact
     ** representation) then converted to REAL by an OP_RealAffinity opcode.
     ** But we are getting ready to store this value back into an index, where
     ** it should be converted by to INTEGER again.  So omit the OP_RealAffinity
     ** opcode if it is present */
     sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity);
   }
   if( regOut ){
     sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
   }
   sqlite3ReleaseTempRange(pParse, regBase, nCol);
   return regBase;
 }

@@ -88944,9 +90460,9 @@ static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){

     case SQLITE_INTEGER: {
       i64 iVal = sqlite3_value_int64(argv[0]);
       if( iVal<0 ){
         if( (iVal<<1)==0 ){
           /* IMP: R-35460-15084 If X is the integer -9223372036854775807 then
           ** abs(X) throws an integer overflow error since there is no
         if( iVal==SMALLEST_INT64 ){
           /* IMP: R-31676-45509 If X is the integer -9223372036854775808
           ** then abs(X) throws an integer overflow error since there is no
           ** equivalent positive 64-bit two complement value. */
           sqlite3_result_error(context, "integer overflow", -1);
           return;

@@ -89026,6 +90542,32 @@ static void instrFunc(

 }
 /*
 ** Implementation of the printf() function.
 */
 static void printfFunc(
   sqlite3_context *context,
   int argc,
   sqlite3_value **argv
 ){
   PrintfArguments x;
   StrAccum str;
   const char *zFormat;
   int n;
   if( argc>=1 && (zFormat = (const char*)sqlite3_value_text(argv[0]))!=0 ){
     x.nArg = argc-1;
     x.nUsed = 0;
     x.apArg = argv+1;
     sqlite3StrAccumInit(&str, 0, 0, SQLITE_MAX_LENGTH);
     str.db = sqlite3_context_db_handle(context);
     sqlite3XPrintf(&str, SQLITE_PRINTF_SQLFUNC, zFormat, &x);
     n = str.nChar;
     sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
                         SQLITE_DYNAMIC);
   }
 }
 /*
 ** Implementation of the substr() function.
 **
 ** substr(x,p1,p2)  returns p2 characters of x[] beginning with p1.

@@ -89798,7 +91340,7 @@ static void charFunc(

 ){
   unsigned char *z, *zOut;
   int i;
   zOut = z = sqlite3_malloc( argc*4 );
   zOut = z = sqlite3_malloc( argc*4+1 );
   if( z==0 ){
     sqlite3_result_error_nomem(context);
     return;

@@ -90318,11 +91860,11 @@ static void groupConcatStep(

         zSep = ",";
         nSep = 1;
       }
       sqlite3StrAccumAppend(pAccum, zSep, nSep);
       if( nSep ) sqlite3StrAccumAppend(pAccum, zSep, nSep);
     }
     zVal = (char*)sqlite3_value_text(argv[0]);
     nVal = sqlite3_value_bytes(argv[0]);
     sqlite3StrAccumAppend(pAccum, zVal, nVal);
     if( nVal ) sqlite3StrAccumAppend(pAccum, zVal, nVal);
   }
 }
 static void groupConcatFinalize(sqlite3_context *context){

@@ -90455,6 +91997,7 @@ SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void){

     FUNCTION(instr,              2, 0, 0, instrFunc        ),
     FUNCTION(substr,             2, 0, 0, substrFunc       ),
     FUNCTION(substr,             3, 0, 0, substrFunc       ),
     FUNCTION(printf,            -1, 0, 0, printfFunc       ),
     FUNCTION(unicode,            1, 0, 0, unicodeFunc      ),
     FUNCTION(char,              -1, 0, 0, charFunc         ),
     FUNCTION(abs,                1, 0, 0, absFunc          ),

@@ -90471,8 +92014,8 @@ SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void){

     FUNCTION2(ifnull,            2, 0, 0, noopFunc,  SQLITE_FUNC_COALESCE),
     FUNCTION2(unlikely,          1, 0, 0, noopFunc,  SQLITE_FUNC_UNLIKELY),
     FUNCTION2(likelihood,        2, 0, 0, noopFunc,  SQLITE_FUNC_UNLIKELY),
     FUNCTION(random,             0, 0, 0, randomFunc       ),
     FUNCTION(randomblob,         1, 0, 0, randomBlob       ),
     VFUNCTION(random,            0, 0, 0, randomFunc       ),
     VFUNCTION(randomblob,        1, 0, 0, randomBlob       ),
     FUNCTION(nullif,             2, 0, 1, nullifFunc       ),
     FUNCTION(sqlite_version,     0, 0, 0, versionFunc      ),
     FUNCTION(sqlite_source_id,   0, 0, 0, sourceidFunc     ),

@@ -90482,9 +92025,9 @@ SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void){

     FUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc  ),
 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
     FUNCTION(quote,              1, 0, 0, quoteFunc        ),
     FUNCTION(last_insert_rowid,  0, 0, 0, last_insert_rowid),
     FUNCTION(changes,            0, 0, 0, changes          ),
     FUNCTION(total_changes,      0, 0, 0, total_changes    ),
     VFUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid),
     VFUNCTION(changes,           0, 0, 0, changes          ),
     VFUNCTION(total_changes,     0, 0, 0, total_changes    ),
     FUNCTION(replace,            3, 0, 0, replaceFunc      ),
     FUNCTION(zeroblob,           1, 0, 0, zeroblobFunc     ),
   #ifdef SQLITE_SOUNDEX

@@ -90757,7 +92300,7 @@ SQLITE_PRIVATE int sqlite3FkLocateIndex(

   }
   for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
     if( pIdx->nColumn==nCol && pIdx->onError!=OE_None ){
     if( pIdx->nKeyCol==nCol && pIdx->onError!=OE_None ){
       /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number
       ** of columns. If each indexed column corresponds to a foreign key
       ** column of pFKey, then this index is a winner.  */

@@ -90780,7 +92323,7 @@ SQLITE_PRIVATE int sqlite3FkLocateIndex(

         ** the default collation sequences for each column. */
         int i, j;
         for(i=0; i<nCol; i++){
           int iCol = pIdx->aiColumn[i];     /* Index of column in parent tbl */
           i16 iCol = pIdx->aiColumn[i];     /* Index of column in parent tbl */
           char *zDfltColl;                  /* Def. collation for column */
           char *zIdxCol;                    /* Name of indexed column */

@@ -90872,10 +92415,11 @@ static void fkLookupParent(

   ** search for a matching row in the parent table.  */
   if( nIncr<0 ){
     sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk);
     VdbeCoverage(v);
   }
   for(i=0; i<pFKey->nCol; i++){
     int iReg = aiCol[i] + regData + 1;
     sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk);
     sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk); VdbeCoverage(v);
   }
   if( isIgnore==0 ){

@@ -90892,17 +92436,19 @@ static void fkLookupParent(

       ** will have INTEGER affinity applied to it, which may not be correct.  */
       sqlite3VdbeAddOp2(v, OP_SCopy, aiCol[0]+1+regData, regTemp);
       iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0);
       VdbeCoverage(v);
       /* If the parent table is the same as the child table, and we are about
       ** to increment the constraint-counter (i.e. this is an INSERT operation),
       ** then check if the row being inserted matches itself. If so, do not
       ** increment the constraint-counter.  */
       if( pTab==pFKey->pFrom && nIncr==1 ){
         sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp);
         sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp); VdbeCoverage(v);
         sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
       }
       sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
       sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp);
       sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v);
       sqlite3VdbeAddOp2(v, OP_Goto, 0, iOk);
       sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
       sqlite3VdbeJumpHere(v, iMustBeInt);

@@ -90911,10 +92457,9 @@ static void fkLookupParent(

       int nCol = pFKey->nCol;
       int regTemp = sqlite3GetTempRange(pParse, nCol);
       int regRec = sqlite3GetTempReg(pParse);
       KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
       sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
       sqlite3VdbeChangeP4(v, -1, (char*)pKey, P4_KEYINFO_HANDOFF);
       sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
       for(i=0; i<nCol; i++){
         sqlite3VdbeAddOp2(v, OP_Copy, aiCol[i]+1+regData, regTemp+i);
       }

@@ -90939,15 +92484,15 @@ static void fkLookupParent(

             /* The parent key is a composite key that includes the IPK column */
             iParent = regData;
           }
           sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent);
           sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent); VdbeCoverage(v);
           sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
         }
         sqlite3VdbeAddOp2(v, OP_Goto, 0, iOk);
       }
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regTemp, nCol, regRec);
       sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v,pIdx), P4_TRANSIENT);
       sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regRec, 0);
       sqlite3VdbeAddOp4(v, OP_MakeRecord, regTemp, nCol, regRec,
                         sqlite3IndexAffinityStr(v,pIdx), nCol);
       sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regRec, 0); VdbeCoverage(v);
       sqlite3ReleaseTempReg(pParse, regRec);
       sqlite3ReleaseTempRange(pParse, regTemp, nCol);

@@ -90964,8 +92509,7 @@ static void fkLookupParent(

     ** generated for will not open a statement transaction.  */
     assert( nIncr==1 );
     sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
         OE_Abort, "foreign key constraint failed", P4_STATIC
     );
         OE_Abort, 0, P4_STATIC, P5_ConstraintFK);
   }else{
     if( nIncr>0 && pFKey->isDeferred==0 ){
       sqlite3ParseToplevel(pParse)->mayAbort = 1;

@@ -90977,6 +92521,62 @@ static void fkLookupParent(

   sqlite3VdbeAddOp1(v, OP_Close, iCur);
 }
 /*
 ** Return an Expr object that refers to a memory register corresponding
 ** to column iCol of table pTab.
 **
 ** regBase is the first of an array of register that contains the data
 ** for pTab.  regBase itself holds the rowid.  regBase+1 holds the first
 ** column.  regBase+2 holds the second column, and so forth.
 */
 static Expr *exprTableRegister(
   Parse *pParse,     /* Parsing and code generating context */
   Table *pTab,       /* The table whose content is at r[regBase]... */
   int regBase,       /* Contents of table pTab */
   i16 iCol           /* Which column of pTab is desired */
 ){
   Expr *pExpr;
   Column *pCol;
   const char *zColl;
   sqlite3 *db = pParse->db;
   pExpr = sqlite3Expr(db, TK_REGISTER, 0);
   if( pExpr ){
     if( iCol>=0 && iCol!=pTab->iPKey ){
       pCol = &pTab->aCol[iCol];
       pExpr->iTable = regBase + iCol + 1;
       pExpr->affinity = pCol->affinity;
       zColl = pCol->zColl;
       if( zColl==0 ) zColl = db->pDfltColl->zName;
       pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
     }else{
       pExpr->iTable = regBase;
       pExpr->affinity = SQLITE_AFF_INTEGER;
     }
   }
   return pExpr;
 }
 /*
 ** Return an Expr object that refers to column iCol of table pTab which
 ** has cursor iCur.
 */
 static Expr *exprTableColumn(
   sqlite3 *db,      /* The database connection */
   Table *pTab,      /* The table whose column is desired */
   int iCursor,      /* The open cursor on the table */
   i16 iCol          /* The column that is wanted */
 ){
   Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
   if( pExpr ){
     pExpr->pTab = pTab;
     pExpr->iTable = iCursor;
     pExpr->iColumn = iCol;
   }
   return pExpr;
 }
 /*
 ** This function is called to generate code executed when a row is deleted
 ** from the parent table of foreign key constraint pFKey and, if pFKey is

@@ -90992,13 +92592,13 @@ static void fkLookupParent(

 **   --------------------------------------------------------------------------
 **   DELETE      immediate   Increment the "immediate constraint counter".
 **                           Or, if the ON (UPDATE|DELETE) action is RESTRICT,
 **                           throw a "foreign key constraint failed" exception.
 **                           throw a "FOREIGN KEY constraint failed" exception.
 **
 **   INSERT      immediate   Decrement the "immediate constraint counter".
 **
 **   DELETE      deferred    Increment the "deferred constraint counter".
 **                           Or, if the ON (UPDATE|DELETE) action is RESTRICT,
 **                           throw a "foreign key constraint failed" exception.
 **                           throw a "FOREIGN KEY constraint failed" exception.
 **
 **   INSERT      deferred    Decrement the "deferred constraint counter".
 **

@@ -91007,12 +92607,12 @@ static void fkLookupParent(

 */
 static void fkScanChildren(
   Parse *pParse,                  /* Parse context */
   SrcList *pSrc,                  /* SrcList containing the table to scan */
   Table *pTab,
   Index *pIdx,                    /* Foreign key index */
   FKey *pFKey,                    /* Foreign key relationship */
   SrcList *pSrc,                  /* The child table to be scanned */
   Table *pTab,                    /* The parent table */
   Index *pIdx,                    /* Index on parent covering the foreign key */
   FKey *pFKey,                    /* The foreign key linking pSrc to pTab */
   int *aiCol,                     /* Map from pIdx cols to child table cols */
   int regData,                    /* Referenced table data starts here */
   int regData,                    /* Parent row data starts here */
   int nIncr                       /* Amount to increment deferred counter by */
 ){
   sqlite3 *db = pParse->db;       /* Database handle */

@@ -91023,10 +92623,14 @@ static void fkScanChildren(

   int iFkIfZero = 0;              /* Address of OP_FkIfZero */
   Vdbe *v = sqlite3GetVdbe(pParse);
   assert( !pIdx || pIdx->pTable==pTab );
   assert( pIdx==0 || pIdx->pTable==pTab );
   assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
   assert( pIdx!=0 || pFKey->nCol==1 );
   assert( pIdx!=0 || HasRowid(pTab) );
   if( nIncr<0 ){
     iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0);
     VdbeCoverage(v);
   }
   /* Create an Expr object representing an SQL expression like:

@@ -91041,29 +92645,11 @@ static void fkScanChildren(

     Expr *pLeft;                  /* Value from parent table row */
     Expr *pRight;                 /* Column ref to child table */
     Expr *pEq;                    /* Expression (pLeft = pRight) */
     int iCol;                     /* Index of column in child table */
     i16 iCol;                     /* Index of column in child table */
     const char *zCol;             /* Name of column in child table */
     pLeft = sqlite3Expr(db, TK_REGISTER, 0);
     if( pLeft ){
       /* Set the collation sequence and affinity of the LHS of each TK_EQ
       ** expression to the parent key column defaults.  */
       if( pIdx ){
         Column *pCol;
         const char *zColl;
         iCol = pIdx->aiColumn[i];
         pCol = &pTab->aCol[iCol];
         if( pTab->iPKey==iCol ) iCol = -1;
         pLeft->iTable = regData+iCol+1;
         pLeft->affinity = pCol->affinity;
         zColl = pCol->zColl;
         if( zColl==0 ) zColl = db->pDfltColl->zName;
         pLeft = sqlite3ExprAddCollateString(pParse, pLeft, zColl);
       }else{
         pLeft->iTable = regData;
         pLeft->affinity = SQLITE_AFF_INTEGER;
       }
     }
     iCol = pIdx ? pIdx->aiColumn[i] : -1;
     pLeft = exprTableRegister(pParse, pTab, regData, iCol);
     iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
     assert( iCol>=0 );
     zCol = pFKey->pFrom->aCol[iCol].zName;

@@ -91072,24 +92658,39 @@ static void fkScanChildren(

     pWhere = sqlite3ExprAnd(db, pWhere, pEq);
   }
   /* If the child table is the same as the parent table, and this scan
   ** is taking place as part of a DELETE operation (operation D.2), omit the
   ** row being deleted from the scan by adding ($rowid != rowid) to the WHERE
   ** clause, where $rowid is the rowid of the row being deleted.  */
   /* If the child table is the same as the parent table, then add terms
   ** to the WHERE clause that prevent this entry from being scanned.
   ** The added WHERE clause terms are like this:
   **
   **     $current_rowid!=rowid
   **     NOT( $current_a==a AND $current_b==b AND ... )
   **
   ** The first form is used for rowid tables.  The second form is used
   ** for WITHOUT ROWID tables.  In the second form, the primary key is
   ** (a,b,...)
   */
   if( pTab==pFKey->pFrom && nIncr>0 ){
     Expr *pEq;                    /* Expression (pLeft = pRight) */
     Expr *pNe;                    /* Expression (pLeft != pRight) */
     Expr *pLeft;                  /* Value from parent table row */
     Expr *pRight;                 /* Column ref to child table */
     pLeft = sqlite3Expr(db, TK_REGISTER, 0);
     pRight = sqlite3Expr(db, TK_COLUMN, 0);
     if( pLeft && pRight ){
       pLeft->iTable = regData;
       pLeft->affinity = SQLITE_AFF_INTEGER;
       pRight->iTable = pSrc->a[0].iCursor;
       pRight->iColumn = -1;
     }
     pEq = sqlite3PExpr(pParse, TK_NE, pLeft, pRight, 0);
     pWhere = sqlite3ExprAnd(db, pWhere, pEq);
     if( HasRowid(pTab) ){
       pLeft = exprTableRegister(pParse, pTab, regData, -1);
       pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, -1);
       pNe = sqlite3PExpr(pParse, TK_NE, pLeft, pRight, 0);
     }else{
       Expr *pEq, *pAll = 0;
       Index *pPk = sqlite3PrimaryKeyIndex(pTab);
       assert( pIdx!=0 );
       for(i=0; i<pPk->nKeyCol; i++){
         i16 iCol = pIdx->aiColumn[i];
         pLeft = exprTableRegister(pParse, pTab, regData, iCol);
         pRight = exprTableColumn(db, pTab, pSrc->a[0].iCursor, iCol);
         pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0);
         pAll = sqlite3ExprAnd(db, pAll, pEq);
       }
       pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0, 0);
     }
     pWhere = sqlite3ExprAnd(db, pWhere, pNe);
   }
   /* Resolve the references in the WHERE clause. */

@@ -91119,8 +92720,8 @@ static void fkScanChildren(

 }
 /*
 ** This function returns a pointer to the head of a linked list of FK
 ** constraints for which table pTab is the parent table. For example,
 ** This function returns a linked list of FKey objects (connected by
 ** FKey.pNextTo) holding all children of table pTab.  For example,
 ** given the following schema:
 **
 **   CREATE TABLE t1(a PRIMARY KEY);

@@ -91192,7 +92793,7 @@ SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTa

       }
       if( !p ) return;
       iSkip = sqlite3VdbeMakeLabel(v);
       sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip);
       sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v);
     }
     pParse->disableTriggers = 1;

@@ -91210,9 +92811,9 @@ SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTa

     */
     if( (db->flags & SQLITE_DeferFKs)==0 ){
       sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2);
       VdbeCoverage(v);
       sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
           OE_Abort, "foreign key constraint failed", P4_STATIC
       );
           OE_Abort, 0, P4_STATIC, P5_ConstraintFK);
     }
     if( iSkip ){

@@ -91370,7 +92971,7 @@ SQLITE_PRIVATE void sqlite3FkCheck(

         int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
         for(i=0; i<pFKey->nCol; i++){
           int iReg = pFKey->aCol[i].iFrom + regOld + 1;
           sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump);
           sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v);
         }
         sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1);
       }

@@ -91422,7 +93023,8 @@ SQLITE_PRIVATE void sqlite3FkCheck(

     sqlite3DbFree(db, aiFree);
   }
   /* Loop through all the foreign key constraints that refer to this table */
   /* Loop through all the foreign key constraints that refer to this table.
   ** (the "child" constraints) */
   for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
     Index *pIdx = 0;              /* Foreign key index for pFKey */
     SrcList *pSrc;

@@ -91447,9 +93049,8 @@ SQLITE_PRIVATE void sqlite3FkCheck(

     }
     assert( aiCol || pFKey->nCol==1 );
     /* Create a SrcList structure containing a single table (the table
     ** the foreign key that refers to this table is attached to). This
     ** is required for the sqlite3WhereXXX() interface.  */
     /* Create a SrcList structure containing the child table.  We need the
     ** child table as a SrcList for sqlite3WhereBegin() */
     pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
     if( pSrc ){
       struct SrcList_item *pItem = pSrc->a;

@@ -91498,7 +93099,7 @@ SQLITE_PRIVATE u32 sqlite3FkOldmask(

       Index *pIdx = 0;
       sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
       if( pIdx ){
         for(i=0; i<pIdx->nColumn; i++) mask |= COLUMN_MASK(pIdx->aiColumn[i]);
         for(i=0; i<pIdx->nKeyCol; i++) mask |= COLUMN_MASK(pIdx->aiColumn[i]);
       }
     }
   }

@@ -91690,7 +93291,7 @@ static Trigger *fkActionTrigger(

       tFrom.z = zFrom;
       tFrom.n = nFrom;
       pRaise = sqlite3Expr(db, TK_RAISE, "foreign key constraint failed");
       pRaise = sqlite3Expr(db, TK_RAISE, "FOREIGN KEY constraint failed");
       if( pRaise ){
         pRaise->affinity = OE_Abort;
       }

@@ -91854,10 +93455,16 @@ SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){

 */
 /*
 ** Generate code that will open a table for reading.
 ** Generate code that will
 **
 **   (1) acquire a lock for table pTab then
 **   (2) open pTab as cursor iCur.
 **
 ** If pTab is a WITHOUT ROWID table, then it is the PRIMARY KEY index
 ** for that table that is actually opened.
 */
 SQLITE_PRIVATE void sqlite3OpenTable(
   Parse *p,       /* Generate code into this VDBE */
   Parse *pParse,  /* Generate code into this VDBE */
   int iCur,       /* The cursor number of the table */
   int iDb,        /* The database index in sqlite3.aDb[] */
   Table *pTab,    /* The table to be opened */

@@ -91865,12 +93472,21 @@ SQLITE_PRIVATE void sqlite3OpenTable(

 ){
   Vdbe *v;
   assert( !IsVirtual(pTab) );
   v = sqlite3GetVdbe(p);
   v = sqlite3GetVdbe(pParse);
   assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
   sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);
   sqlite3VdbeAddOp3(v, opcode, iCur, pTab->tnum, iDb);
   sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(pTab->nCol), P4_INT32);
   VdbeComment((v, "%s", pTab->zName));
   sqlite3TableLock(pParse, iDb, pTab->tnum,
                    (opcode==OP_OpenWrite)?1:0, pTab->zName);
   if( HasRowid(pTab) ){
     sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nCol);
     VdbeComment((v, "%s", pTab->zName));
   }else{
     Index *pPk = sqlite3PrimaryKeyIndex(pTab);
     assert( pPk!=0 );
     assert( pPk->tnum=pTab->tnum );
     sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
     sqlite3VdbeSetP4KeyInfo(pParse, pPk);
     VdbeComment((v, "%s", pTab->zName));
   }
 }
 /*

@@ -91906,15 +93522,15 @@ SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){

     int n;
     Table *pTab = pIdx->pTable;
     sqlite3 *db = sqlite3VdbeDb(v);
     pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+2);
     pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
     if( !pIdx->zColAff ){
       db->mallocFailed = 1;
       return 0;
     }
     for(n=0; n<pIdx->nColumn; n++){
       pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
       i16 x = pIdx->aiColumn[n];
       pIdx->zColAff[n] = x<0 ? SQLITE_AFF_INTEGER : pTab->aCol[x].affinity;
     }
     pIdx->zColAff[n++] = SQLITE_AFF_INTEGER;
     pIdx->zColAff[n] = 0;
   }

@@ -91922,10 +93538,16 @@ SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){

 }
 /*
 ** Set P4 of the most recently inserted opcode to a column affinity
 ** string for table pTab. A column affinity string has one character
 ** for each column indexed by the index, according to the affinity of the
 ** column:
 ** Compute the affinity string for table pTab, if it has not already been
 ** computed.  As an optimization, omit trailing SQLITE_AFF_NONE affinities.
 **
 ** If the affinity exists (if it is no entirely SQLITE_AFF_NONE values) and
 ** if iReg>0 then code an OP_Affinity opcode that will set the affinities
 ** for register iReg and following.  Or if affinities exists and iReg==0,
 ** then just set the P4 operand of the previous opcode (which should  be
 ** an OP_MakeRecord) to the affinity string.
 **
 ** A column affinity string has one character per column:
 **
 **  Character      Column affinity
 **  ------------------------------

@@ -91935,19 +93557,11 @@ SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){

 **  'd'            INTEGER
 **  'e'            REAL
 */
 SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
   /* The first time a column affinity string for a particular table
   ** is required, it is allocated and populated here. It is then
   ** stored as a member of the Table structure for subsequent use.
   **
   ** The column affinity string will eventually be deleted by
   ** sqlite3DeleteTable() when the Table structure itself is cleaned up.
   */
   if( !pTab->zColAff ){
     char *zColAff;
     int i;
 SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
   int i;
   char *zColAff = pTab->zColAff;
   if( zColAff==0 ){
     sqlite3 *db = sqlite3VdbeDb(v);
     zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
     if( !zColAff ){
       db->mallocFailed = 1;

@@ -91957,22 +93571,28 @@ SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){

     for(i=0; i<pTab->nCol; i++){
       zColAff[i] = pTab->aCol[i].affinity;
     }
     zColAff[pTab->nCol] = '\0';
     do{
       zColAff[i--] = 0;
     }while( i>=0 && zColAff[i]==SQLITE_AFF_NONE );
     pTab->zColAff = zColAff;
   }
   sqlite3VdbeChangeP4(v, -1, pTab->zColAff, P4_TRANSIENT);
   i = sqlite3Strlen30(zColAff);
   if( i ){
     if( iReg ){
       sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
     }else{
       sqlite3VdbeChangeP4(v, -1, zColAff, i);
     }
   }
 }
 /*
 ** Return non-zero if the table pTab in database iDb or any of its indices
 ** have been opened at any point in the VDBE program beginning at location
 ** iStartAddr throught the end of the program.  This is used to see if
 ** have been opened at any point in the VDBE program. This is used to see if
 ** a statement of the form  "INSERT INTO <iDb, pTab> SELECT ..." can
 ** run without using temporary table for the results of the SELECT.
 ** run without using a temporary table for the results of the SELECT.
 */
 static int readsTable(Parse *p, int iStartAddr, int iDb, Table *pTab){
 static int readsTable(Parse *p, int iDb, Table *pTab){
   Vdbe *v = sqlite3GetVdbe(p);
   int i;
   int iEnd = sqlite3VdbeCurrentAddr(v);

@@ -91980,7 +93600,7 @@ static int readsTable(Parse *p, int iStartAddr, int iDb, Table *pTab){

   VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
 #endif
   for(i=iStartAddr; i<iEnd; i++){
   for(i=1; i<iEnd; i++){
     VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
     assert( pOp!=0 );
     if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){

@@ -92081,14 +93701,14 @@ SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){

     sqlite3VdbeAddOp3(v, OP_Null, 0, memId, memId+1);
     addr = sqlite3VdbeCurrentAddr(v);
     sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
     sqlite3VdbeAddOp2(v, OP_Rewind, 0, addr+9);
     sqlite3VdbeAddOp2(v, OP_Rewind, 0, addr+9); VdbeCoverage(v);
     sqlite3VdbeAddOp3(v, OP_Column, 0, 0, memId);
     sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId);
     sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId); VdbeCoverage(v);
     sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
     sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
     sqlite3VdbeAddOp3(v, OP_Column, 0, 1, memId);
     sqlite3VdbeAddOp2(v, OP_Goto, 0, addr+9);
     sqlite3VdbeAddOp2(v, OP_Next, 0, addr+2);
     sqlite3VdbeAddOp2(v, OP_Next, 0, addr+2); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Integer, 0, memId);
     sqlite3VdbeAddOp0(v, OP_Close);
   }

@@ -92123,25 +93743,16 @@ SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){

   assert( v );
   for(p = pParse->pAinc; p; p = p->pNext){
     Db *pDb = &db->aDb[p->iDb];
     int j1, j2, j3, j4, j5;
     int j1;
     int iRec;
     int memId = p->regCtr;
     iRec = sqlite3GetTempReg(pParse);
     assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
     sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
     j1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1);
     j2 = sqlite3VdbeAddOp0(v, OP_Rewind);
     j3 = sqlite3VdbeAddOp3(v, OP_Column, 0, 0, iRec);
     j4 = sqlite3VdbeAddOp3(v, OP_Eq, memId-1, 0, iRec);
     sqlite3VdbeAddOp2(v, OP_Next, 0, j3);
     sqlite3VdbeJumpHere(v, j2);
     j1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_NewRowid, 0, memId+1);
     j5 = sqlite3VdbeAddOp0(v, OP_Goto);
     sqlite3VdbeJumpHere(v, j4);
     sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
     sqlite3VdbeJumpHere(v, j1);
     sqlite3VdbeJumpHere(v, j5);
     sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);
     sqlite3VdbeAddOp3(v, OP_Insert, 0, iRec, memId+1);
     sqlite3VdbeChangeP5(v, OPFLAG_APPEND);

@@ -92159,97 +93770,6 @@ SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){

 #endif /* SQLITE_OMIT_AUTOINCREMENT */
 /*
 ** Generate code for a co-routine that will evaluate a subquery one
 ** row at a time.
 **
 ** The pSelect parameter is the subquery that the co-routine will evaluation.
 ** Information about the location of co-routine and the registers it will use
 ** is returned by filling in the pDest object.
 **
 ** Registers are allocated as follows:
 **
 **   pDest->iSDParm      The register holding the next entry-point of the
 **                       co-routine.  Run the co-routine to its next breakpoint
 **                       by calling "OP_Yield $X" where $X is pDest->iSDParm.
 **
 **   pDest->iSDParm+1    The register holding the "completed" flag for the
 **                       co-routine. This register is 0 if the previous Yield
 **                       generated a new result row, or 1 if the subquery
 **                       has completed.  If the Yield is called again
 **                       after this register becomes 1, then the VDBE will
 **                       halt with an SQLITE_INTERNAL error.
 **
 **   pDest->iSdst        First result register.
 **
 **   pDest->nSdst        Number of result registers.
 **
 ** This routine handles all of the register allocation and fills in the
 ** pDest structure appropriately.
 **
 ** Here is a schematic of the generated code assuming that X is the
 ** co-routine entry-point register reg[pDest->iSDParm], that EOF is the
 ** completed flag reg[pDest->iSDParm+1], and R and S are the range of
 ** registers that hold the result set, reg[pDest->iSdst] through
 ** reg[pDest->iSdst+pDest->nSdst-1]:
 **
 **         X <- A
 **         EOF <- 0
 **         goto B
 **      A: setup for the SELECT
 **         loop rows in the SELECT
 **           load results into registers R..S
 **           yield X
 **         end loop
 **         cleanup after the SELECT
 **         EOF <- 1
 **         yield X
 **         halt-error
 **      B:
 **
 ** To use this subroutine, the caller generates code as follows:
 **
 **         [ Co-routine generated by this subroutine, shown above ]
 **      S: yield X
 **         if EOF goto E
 **         if skip this row, goto C
 **         if terminate loop, goto E
 **         deal with this row
 **      C: goto S
 **      E:
 */
 SQLITE_PRIVATE int sqlite3CodeCoroutine(Parse *pParse, Select *pSelect, SelectDest *pDest){
   int regYield;       /* Register holding co-routine entry-point */
   int regEof;         /* Register holding co-routine completion flag */
   int addrTop;        /* Top of the co-routine */
   int j1;             /* Jump instruction */
   int rc;             /* Result code */
   Vdbe *v;            /* VDBE under construction */
   regYield = ++pParse->nMem;
   regEof = ++pParse->nMem;
   v = sqlite3GetVdbe(pParse);
   addrTop = sqlite3VdbeCurrentAddr(v);
   sqlite3VdbeAddOp2(v, OP_Integer, addrTop+2, regYield); /* X <- A */
   VdbeComment((v, "Co-routine entry point"));
   sqlite3VdbeAddOp2(v, OP_Integer, 0, regEof);           /* EOF <- 0 */
   VdbeComment((v, "Co-routine completion flag"));
   sqlite3SelectDestInit(pDest, SRT_Coroutine, regYield);
   j1 = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
   rc = sqlite3Select(pParse, pSelect, pDest);
   assert( pParse->nErr==0 || rc );
   if( pParse->db->mallocFailed && rc==SQLITE_OK ) rc = SQLITE_NOMEM;
   if( rc ) return rc;
   sqlite3VdbeAddOp2(v, OP_Integer, 1, regEof);            /* EOF <- 1 */
   sqlite3VdbeAddOp1(v, OP_Yield, regYield);   /* yield X */
   sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_INTERNAL, OE_Abort);
   VdbeComment((v, "End of coroutine"));
   sqlite3VdbeJumpHere(v, j1);                             /* label B: */
   return rc;
 }
 /* Forward declaration */
 static int xferOptimization(
   Parse *pParse,        /* Parser context */

@@ -92260,7 +93780,7 @@ static int xferOptimization(

 );
 /*
 ** This routine is call to handle SQL of the following forms:
 ** This routine is called to handle SQL of the following forms:
 **
 **    insert into TABLE (IDLIST) values(EXPRLIST)
 **    insert into TABLE (IDLIST) select

@@ -92275,12 +93795,12 @@ static int xferOptimization(

 ** data for the insert.
 **
 ** The code generated follows one of four templates.  For a simple
 ** select with data coming from a VALUES clause, the code executes
 ** insert with data coming from a VALUES clause, the code executes
 ** once straight down through.  Pseudo-code follows (we call this
 ** the "1st template"):
 **
 **         open write cursor to <table> and its indices
 **         puts VALUES clause expressions onto the stack
 **         put VALUES clause expressions into registers
 **         write the resulting record into <table>
 **         cleanup
 **

@@ -92312,7 +93832,6 @@ static int xferOptimization(

 ** and the SELECT clause does not read from <table> at any time.
 ** The generated code follows this template:
 **
 **         EOF <- 0
 **         X <- A
 **         goto B
 **      A: setup for the SELECT

@@ -92321,12 +93840,9 @@ static int xferOptimization(

 **           yield X
 **         end loop
 **         cleanup after the SELECT
 **         EOF <- 1
 **         yield X
 **         goto A
 **         end-coroutine X
 **      B: open write cursor to <table> and its indices
 **      C: yield X
 **         if EOF goto D
 **      C: yield X, at EOF goto D
 **         insert the select result into <table> from R..R+n
 **         goto C
 **      D: cleanup

@@ -92337,7 +93853,6 @@ static int xferOptimization(

 ** we have to use a intermediate table to store the results of
 ** the select.  The template is like this:
 **
 **         EOF <- 0
 **         X <- A
 **         goto B
 **      A: setup for the SELECT

@@ -92346,12 +93861,9 @@ static int xferOptimization(

 **           yield X
 **         end loop
 **         cleanup after the SELECT
 **         EOF <- 1
 **         yield X
 **         halt-error
 **         end co-routine R
 **      B: open temp table
 **      L: yield X
 **         if EOF goto M
 **      L: yield X, at EOF goto M
 **         insert row from R..R+n into temp table
 **         goto L
 **      M: open write cursor to <table> and its indices

@@ -92364,7 +93876,6 @@ static int xferOptimization(

 SQLITE_PRIVATE void sqlite3Insert(
   Parse *pParse,        /* Parser context */
   SrcList *pTabList,    /* Name of table into which we are inserting */
   ExprList *pList,      /* List of values to be inserted */
   Select *pSelect,      /* A SELECT statement to use as the data source */
   IdList *pColumn,      /* Column names corresponding to IDLIST. */
   int onError           /* How to handle constraint errors */

@@ -92378,18 +93889,21 @@ SQLITE_PRIVATE void sqlite3Insert(

   Index *pIdx;          /* For looping over indices of the table */
   int nColumn;          /* Number of columns in the data */
   int nHidden = 0;      /* Number of hidden columns if TABLE is virtual */
   int baseCur = 0;      /* VDBE Cursor number for pTab */
   int keyColumn = -1;   /* Column that is the INTEGER PRIMARY KEY */
   int iDataCur = 0;     /* VDBE cursor that is the main data repository */
   int iIdxCur = 0;      /* First index cursor */
   int ipkColumn = -1;   /* Column that is the INTEGER PRIMARY KEY */
   int endOfLoop;        /* Label for the end of the insertion loop */
   int useTempTable = 0; /* Store SELECT results in intermediate table */
   int srcTab = 0;       /* Data comes from this temporary cursor if >=0 */
   int addrInsTop = 0;   /* Jump to label "D" */
   int addrCont = 0;     /* Top of insert loop. Label "C" in templates 3 and 4 */
   int addrSelect = 0;   /* Address of coroutine that implements the SELECT */
   SelectDest dest;      /* Destination for SELECT on rhs of INSERT */
   int iDb;              /* Index of database holding TABLE */
   Db *pDb;              /* The database containing table being inserted into */
   int appendFlag = 0;   /* True if the insert is likely to be an append */
   u8 useTempTable = 0;  /* Store SELECT results in intermediate table */
   u8 appendFlag = 0;    /* True if the insert is likely to be an append */
   u8 withoutRowid;      /* 0 for normal table.  1 for WITHOUT ROWID table */
   u8 bIdListInOrder = 1; /* True if IDLIST is in table order */
   ExprList *pList = 0;  /* List of VALUES() to be inserted  */
   /* Register allocations */
   int regFromSelect = 0;/* Base register for data coming from SELECT */

@@ -92398,7 +93912,6 @@ SQLITE_PRIVATE void sqlite3Insert(

   int regIns;           /* Block of regs holding rowid+data being inserted */
   int regRowid;         /* registers holding insert rowid */
   int regData;          /* register holding first column to insert */
   int regEof = 0;       /* Register recording end of SELECT data */
   int *aRegIdx = 0;     /* One register allocated to each index */
 #ifndef SQLITE_OMIT_TRIGGER

@@ -92413,6 +93926,17 @@ SQLITE_PRIVATE void sqlite3Insert(

     goto insert_cleanup;
   }
   /* If the Select object is really just a simple VALUES() list with a
   ** single row values (the common case) then keep that one row of values
   ** and go ahead and discard the Select object
   */
   if( pSelect && (pSelect->selFlags & SF_Values)!=0 && pSelect->pPrior==0 ){
     pList = pSelect->pEList;
     pSelect->pEList = 0;
     sqlite3SelectDelete(db, pSelect);
     pSelect = 0;
   }
   /* Locate the table into which we will be inserting new information.
   */
   assert( pTabList->nSrc==1 );

@@ -92429,6 +93953,7 @@ SQLITE_PRIVATE void sqlite3Insert(

   if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
     goto insert_cleanup;
   }
   withoutRowid = !HasRowid(pTab);
   /* Figure out if we have any triggers and if the table being
   ** inserted into is a view

@@ -92448,16 +93973,13 @@ SQLITE_PRIVATE void sqlite3Insert(

   assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
   /* If pTab is really a view, make sure it has been initialized.
   ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual
   ** module table).
   ** ViewGetColumnNames() is a no-op if pTab is not a view.
   */
   if( sqlite3ViewGetColumnNames(pParse, pTab) ){
     goto insert_cleanup;
   }
   /* Ensure that:
   *  (a) the table is not read-only,
   *  (b) that if it is a view then ON INSERT triggers exist
   /* Cannot insert into a read-only table.
   */
   if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
     goto insert_cleanup;

@@ -92492,33 +94014,92 @@ SQLITE_PRIVATE void sqlite3Insert(

   */
   regAutoinc = autoIncBegin(pParse, iDb, pTab);
   /* Allocate registers for holding the rowid of the new row,
   ** the content of the new row, and the assemblied row record.
   */
   regRowid = regIns = pParse->nMem+1;
   pParse->nMem += pTab->nCol + 1;
   if( IsVirtual(pTab) ){
     regRowid++;
     pParse->nMem++;
   }
   regData = regRowid+1;
   /* If the INSERT statement included an IDLIST term, then make sure
   ** all elements of the IDLIST really are columns of the table and
   ** remember the column indices.
   **
   ** If the table has an INTEGER PRIMARY KEY column and that column
   ** is named in the IDLIST, then record in the ipkColumn variable
   ** the index into IDLIST of the primary key column.  ipkColumn is
   ** the index of the primary key as it appears in IDLIST, not as
   ** is appears in the original table.  (The index of the INTEGER
   ** PRIMARY KEY in the original table is pTab->iPKey.)
   */
   if( pColumn ){
     for(i=0; i<pColumn->nId; i++){
       pColumn->a[i].idx = -1;
     }
     for(i=0; i<pColumn->nId; i++){
       for(j=0; j<pTab->nCol; j++){
         if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
           pColumn->a[i].idx = j;
           if( i!=j ) bIdListInOrder = 0;
           if( j==pTab->iPKey ){
             ipkColumn = i;  assert( !withoutRowid );
           }
           break;
         }
       }
       if( j>=pTab->nCol ){
         if( sqlite3IsRowid(pColumn->a[i].zName) && !withoutRowid ){
           ipkColumn = i;
         }else{
           sqlite3ErrorMsg(pParse, "table %S has no column named %s",
               pTabList, 0, pColumn->a[i].zName);
           pParse->checkSchema = 1;
           goto insert_cleanup;
         }
       }
     }
   }
   /* Figure out how many columns of data are supplied.  If the data
   ** is coming from a SELECT statement, then generate a co-routine that
   ** produces a single row of the SELECT on each invocation.  The
   ** co-routine is the common header to the 3rd and 4th templates.
   */
   if( pSelect ){
     /* Data is coming from a SELECT.  Generate a co-routine to run that
     ** SELECT. */
     int rc = sqlite3CodeCoroutine(pParse, pSelect, &dest);
     if( rc ) goto insert_cleanup;
     regEof = dest.iSDParm + 1;
     /* Data is coming from a SELECT.  Generate a co-routine to run the SELECT */
     int regYield;       /* Register holding co-routine entry-point */
     int addrTop;        /* Top of the co-routine */
     int rc;             /* Result code */
     regYield = ++pParse->nMem;
     addrTop = sqlite3VdbeCurrentAddr(v) + 1;
     sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
     sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
     dest.iSdst = bIdListInOrder ? regData : 0;
     dest.nSdst = pTab->nCol;
     rc = sqlite3Select(pParse, pSelect, &dest);
     regFromSelect = dest.iSdst;
     assert( pParse->nErr==0 || rc );
     if( rc || db->mallocFailed ) goto insert_cleanup;
     sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
     sqlite3VdbeJumpHere(v, addrTop - 1);                       /* label B: */
     assert( pSelect->pEList );
     nColumn = pSelect->pEList->nExpr;
     assert( dest.nSdst==nColumn );
     /* Set useTempTable to TRUE if the result of the SELECT statement
     ** should be written into a temporary table (template 4).  Set to
     ** FALSE if each* row of the SELECT can be written directly into
     ** FALSE if each output row of the SELECT can be written directly into
     ** the destination table (template 3).
     **
     ** A temp table must be used if the table being updated is also one
     ** of the tables being read by the SELECT statement.  Also use a
     ** temp table in the case of row triggers.
     */
     if( pTrigger || readsTable(pParse, addrSelect, iDb, pTab) ){
     if( pTrigger || readsTable(pParse, iDb, pTab) ){
       useTempTable = 1;
     }

@@ -92528,28 +94109,25 @@ SQLITE_PRIVATE void sqlite3Insert(

       ** here is from the 4th template:
       **
       **      B: open temp table
       **      L: yield X
       **         if EOF goto M
       **      L: yield X, goto M at EOF
       **         insert row from R..R+n into temp table
       **         goto L
       **      M: ...
       */
       int regRec;          /* Register to hold packed record */
       int regTempRowid;    /* Register to hold temp table ROWID */
       int addrTop;         /* Label "L" */
       int addrIf;          /* Address of jump to M */
       int addrL;           /* Label "L" */
       srcTab = pParse->nTab++;
       regRec = sqlite3GetTempReg(pParse);
       regTempRowid = sqlite3GetTempReg(pParse);
       sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
       addrTop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
       addrIf = sqlite3VdbeAddOp1(v, OP_If, regEof);
       addrL = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); VdbeCoverage(v);
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
       sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);
       sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);
       sqlite3VdbeAddOp2(v, OP_Goto, 0, addrTop);
       sqlite3VdbeJumpHere(v, addrIf);
       sqlite3VdbeAddOp2(v, OP_Goto, 0, addrL);
       sqlite3VdbeJumpHere(v, addrL);
       sqlite3ReleaseTempReg(pParse, regRec);
       sqlite3ReleaseTempReg(pParse, regTempRowid);
     }

@@ -92570,6 +94148,14 @@ SQLITE_PRIVATE void sqlite3Insert(

     }
   }
   /* If there is no IDLIST term but the table has an integer primary
   ** key, the set the ipkColumn variable to the integer primary key
   ** column index in the original table definition.
   */
   if( pColumn==0 && nColumn>0 ){
     ipkColumn = pTab->iPKey;
   }
   /* Make sure the number of columns in the source data matches the number
   ** of columns to be inserted into the table.
   */

@@ -92588,52 +94174,6 @@ SQLITE_PRIVATE void sqlite3Insert(

     sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
     goto insert_cleanup;
   }
   /* If the INSERT statement included an IDLIST term, then make sure
   ** all elements of the IDLIST really are columns of the table and
   ** remember the column indices.
   **
   ** If the table has an INTEGER PRIMARY KEY column and that column
   ** is named in the IDLIST, then record in the keyColumn variable
   ** the index into IDLIST of the primary key column.  keyColumn is
   ** the index of the primary key as it appears in IDLIST, not as
   ** is appears in the original table.  (The index of the primary
   ** key in the original table is pTab->iPKey.)
   */
   if( pColumn ){
     for(i=0; i<pColumn->nId; i++){
       pColumn->a[i].idx = -1;
     }
     for(i=0; i<pColumn->nId; i++){
       for(j=0; j<pTab->nCol; j++){
         if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
           pColumn->a[i].idx = j;
           if( j==pTab->iPKey ){
             keyColumn = i;
           }
           break;
         }
       }
       if( j>=pTab->nCol ){
         if( sqlite3IsRowid(pColumn->a[i].zName) ){
           keyColumn = i;
         }else{
           sqlite3ErrorMsg(pParse, "table %S has no column named %s",
               pTabList, 0, pColumn->a[i].zName);
           pParse->checkSchema = 1;
           goto insert_cleanup;
         }
       }
     }
   }
   /* If there is no IDLIST term but the table has an integer primary
   ** key, the set the keyColumn variable to the primary key column index
   ** in the original table definition.
   */
   if( pColumn==0 && nColumn>0 ){
     keyColumn = pTab->iPKey;
   }
   /* Initialize the count of rows to be inserted
   */

@@ -92645,9 +94185,8 @@ SQLITE_PRIVATE void sqlite3Insert(

   /* If this is not a view, open the table and and all indices */
   if( !isView ){
     int nIdx;
     baseCur = pParse->nTab;
     nIdx = sqlite3OpenTableAndIndices(pParse, pTab, baseCur, OP_OpenWrite);
     nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, -1, 0,
                                       &iDataCur, &iIdxCur);
     aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1));
     if( aRegIdx==0 ){
       goto insert_cleanup;

@@ -92662,38 +94201,26 @@ SQLITE_PRIVATE void sqlite3Insert(

     /* This block codes the top of loop only.  The complete loop is the
     ** following pseudocode (template 4):
     **
     **         rewind temp table
     **         rewind temp table, if empty goto D
     **      C: loop over rows of intermediate table
     **           transfer values form intermediate table into <table>
     **         end loop
     **      D: ...
     */
     addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab);
     addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab); VdbeCoverage(v);
     addrCont = sqlite3VdbeCurrentAddr(v);
   }else if( pSelect ){
     /* This block codes the top of loop only.  The complete loop is the
     ** following pseudocode (template 3):
     **
     **      C: yield X
     **         if EOF goto D
     **      C: yield X, at EOF goto D
     **         insert the select result into <table> from R..R+n
     **         goto C
     **      D: ...
     */
     addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
     addrInsTop = sqlite3VdbeAddOp1(v, OP_If, regEof);
   }
   /* Allocate registers for holding the rowid of the new row,
   ** the content of the new row, and the assemblied row record.
   */
   regRowid = regIns = pParse->nMem+1;
   pParse->nMem += pTab->nCol + 1;
   if( IsVirtual(pTab) ){
     regRowid++;
     pParse->nMem++;
     addrInsTop = addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
     VdbeCoverage(v);
   }
   regData = regRowid+1;
   /* Run the BEFORE and INSTEAD OF triggers, if there are any
   */

@@ -92707,20 +94234,21 @@ SQLITE_PRIVATE void sqlite3Insert(

     ** we do not know what the unique ID will be (because the insert has
     ** not happened yet) so we substitute a rowid of -1
     */
     if( keyColumn<0 ){
     if( ipkColumn<0 ){
       sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
     }else{
       int j1;
       assert( !withoutRowid );
       if( useTempTable ){
         sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regCols);
         sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regCols);
       }else{
         assert( pSelect==0 );  /* Otherwise useTempTable is true */
         sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regCols);
         sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
       }
       j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols);
       j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols); VdbeCoverage(v);
       sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
       sqlite3VdbeJumpHere(v, j1);
       sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols);
       sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v);
     }
     /* Cannot have triggers on a virtual table. If it were possible,

@@ -92754,8 +94282,7 @@ SQLITE_PRIVATE void sqlite3Insert(

     ** table column affinities.
     */
     if( !isView ){
       sqlite3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);
       sqlite3TableAffinityStr(v, pTab);
       sqlite3TableAffinity(v, pTab, regCols+1);
     }
     /* Fire BEFORE or INSTEAD OF triggers */

@@ -92765,29 +94292,27 @@ SQLITE_PRIVATE void sqlite3Insert(

     sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
   }
   /* Push the record number for the new entry onto the stack.  The
   ** record number is a randomly generate integer created by NewRowid
   ** except when the table has an INTEGER PRIMARY KEY column, in which
   ** case the record number is the same as that column.
   /* Compute the content of the next row to insert into a range of
   ** registers beginning at regIns.
   */
   if( !isView ){
     if( IsVirtual(pTab) ){
       /* The row that the VUpdate opcode will delete: none */
       sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
     }
     if( keyColumn>=0 ){
     if( ipkColumn>=0 ){
       if( useTempTable ){
         sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regRowid);
         sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regRowid);
       }else if( pSelect ){
         sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+keyColumn, regRowid);
         sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid);
       }else{
         VdbeOp *pOp;
         sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
         sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
         pOp = sqlite3VdbeGetOp(v, -1);
         if( ALWAYS(pOp) && pOp->opcode==OP_Null && !IsVirtual(pTab) ){
           appendFlag = 1;
           pOp->opcode = OP_NewRowid;
           pOp->p1 = baseCur;
           pOp->p1 = iDataCur;
           pOp->p2 = regRowid;
           pOp->p3 = regAutoinc;
         }

@@ -92798,24 +94323,24 @@ SQLITE_PRIVATE void sqlite3Insert(

       if( !appendFlag ){
         int j1;
         if( !IsVirtual(pTab) ){
           j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid);
           sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
           j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid); VdbeCoverage(v);
           sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
           sqlite3VdbeJumpHere(v, j1);
         }else{
           j1 = sqlite3VdbeCurrentAddr(v);
           sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, j1+2);
           sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, j1+2); VdbeCoverage(v);
         }
         sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid);
         sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid); VdbeCoverage(v);
       }
     }else if( IsVirtual(pTab) ){
     }else if( IsVirtual(pTab) || withoutRowid ){
       sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
     }else{
       sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
       sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
       appendFlag = 1;
     }
     autoIncStep(pParse, regAutoinc, regRowid);
     /* Push onto the stack, data for all columns of the new entry, beginning
     /* Compute data for all columns of the new entry, beginning
     ** with the first column.
     */
     nHidden = 0;

@@ -92823,10 +94348,11 @@ SQLITE_PRIVATE void sqlite3Insert(

       int iRegStore = regRowid+1+i;
       if( i==pTab->iPKey ){
         /* The value of the INTEGER PRIMARY KEY column is always a NULL.
         ** Whenever this column is read, the record number will be substituted
         ** in its place.  So will fill this column with a NULL to avoid
         ** taking up data space with information that will never be used. */
         sqlite3VdbeAddOp2(v, OP_Null, 0, iRegStore);
         ** Whenever this column is read, the rowid will be substituted
         ** in its place.  Hence, fill this column with a NULL to avoid
         ** taking up data space with information that will never be used.
         ** As there may be shallow copies of this value, make it a soft-NULL */
         sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
         continue;
       }
       if( pColumn==0 ){

@@ -92843,11 +94369,13 @@ SQLITE_PRIVATE void sqlite3Insert(

         }
       }
       if( j<0 || nColumn==0 || (pColumn && j>=pColumn->nId) ){
         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, iRegStore);
         sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
       }else if( useTempTable ){
         sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, iRegStore);
       }else if( pSelect ){
         sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+j, iRegStore);
         if( regFromSelect!=regData ){
           sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+j, iRegStore);
         }
       }else{
         sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
       }

@@ -92867,13 +94395,12 @@ SQLITE_PRIVATE void sqlite3Insert(

 #endif
     {
       int isReplace;    /* Set to true if constraints may cause a replace */
       sqlite3GenerateConstraintChecks(pParse, pTab, baseCur, regIns, aRegIdx,
           keyColumn>=0, 0, onError, endOfLoop, &isReplace
       sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
           regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace
       );
       sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
       sqlite3CompleteInsertion(
           pParse, pTab, baseCur, regIns, aRegIdx, 0, appendFlag, isReplace==0
       );
       sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
                                regIns, aRegIdx, 0, appendFlag, isReplace==0);
     }
   }

@@ -92894,7 +94421,7 @@ SQLITE_PRIVATE void sqlite3Insert(

   */
   sqlite3VdbeResolveLabel(v, endOfLoop);
   if( useTempTable ){
     sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont);
     sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v);
     sqlite3VdbeJumpHere(v, addrInsTop);
     sqlite3VdbeAddOp1(v, OP_Close, srcTab);
   }else if( pSelect ){

@@ -92904,9 +94431,9 @@ SQLITE_PRIVATE void sqlite3Insert(

   if( !IsVirtual(pTab) && !isView ){
     /* Close all tables opened */
     sqlite3VdbeAddOp1(v, OP_Close, baseCur);
     for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
       sqlite3VdbeAddOp1(v, OP_Close, idx+baseCur);
     if( iDataCur<iIdxCur ) sqlite3VdbeAddOp1(v, OP_Close, iDataCur);
     for(idx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
       sqlite3VdbeAddOp1(v, OP_Close, idx+iIdxCur);
     }
   }

@@ -92951,36 +94478,48 @@ insert_cleanup:

  #undef tmask
 #endif
 /*
 ** Generate code to do constraint checks prior to an INSERT or an UPDATE.
 ** Generate code to do constraint checks prior to an INSERT or an UPDATE
 ** on table pTab.
 **
 ** The input is a range of consecutive registers as follows:
 ** The regNewData parameter is the first register in a range that contains
 ** the data to be inserted or the data after the update.  There will be
 ** pTab->nCol+1 registers in this range.  The first register (the one
 ** that regNewData points to) will contain the new rowid, or NULL in the
 ** case of a WITHOUT ROWID table.  The second register in the range will
 ** contain the content of the first table column.  The third register will
 ** contain the content of the second table column.  And so forth.
 **
 **    1.  The rowid of the row after the update.
 ** The regOldData parameter is similar to regNewData except that it contains
 ** the data prior to an UPDATE rather than afterwards.  regOldData is zero
 ** for an INSERT.  This routine can distinguish between UPDATE and INSERT by
 ** checking regOldData for zero.
 **
 **    2.  The data in the first column of the entry after the update.
 ** For an UPDATE, the pkChng boolean is true if the true primary key (the
 ** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table)
 ** might be modified by the UPDATE.  If pkChng is false, then the key of
 ** the iDataCur content table is guaranteed to be unchanged by the UPDATE.
 **
 **    i.  Data from middle columns...
 ** For an INSERT, the pkChng boolean indicates whether or not the rowid
 ** was explicitly specified as part of the INSERT statement.  If pkChng
 ** is zero, it means that the either rowid is computed automatically or
 ** that the table is a WITHOUT ROWID table and has no rowid.  On an INSERT,
 ** pkChng will only be true if the INSERT statement provides an integer
 ** value for either the rowid column or its INTEGER PRIMARY KEY alias.
 **
 **    N.  The data in the last column of the entry after the update.
 **
 ** The regRowid parameter is the index of the register containing (1).
 **
 ** If isUpdate is true and rowidChng is non-zero, then rowidChng contains
 ** the address of a register containing the rowid before the update takes
 ** place. isUpdate is true for UPDATEs and false for INSERTs. If isUpdate
 ** is false, indicating an INSERT statement, then a non-zero rowidChng
 ** indicates that the rowid was explicitly specified as part of the
 ** INSERT statement. If rowidChng is false, it means that  the rowid is
 ** computed automatically in an insert or that the rowid value is not
 ** modified by an update.
 **
 ** The code generated by this routine store new index entries into
 ** The code generated by this routine will store new index entries into
 ** registers identified by aRegIdx[].  No index entry is created for
 ** indices where aRegIdx[i]==0.  The order of indices in aRegIdx[] is
 ** the same as the order of indices on the linked list of indices
 ** attached to the table.
 ** at pTab->pIndex.
 **
 ** The caller must have already opened writeable cursors on the main
 ** table and all applicable indices (that is to say, all indices for which
 ** aRegIdx[] is not zero).  iDataCur is the cursor for the main table when
 ** inserting or updating a rowid table, or the cursor for the PRIMARY KEY
 ** index when operating on a WITHOUT ROWID table.  iIdxCur is the cursor
 ** for the first index in the pTab->pIndex list.  Cursors for other indices
 ** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
 **
 ** This routine also generates code to check constraints.  NOT NULL,
 ** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,

@@ -92990,22 +94529,23 @@ insert_cleanup:

 **  Constraint type  Action       What Happens
 **  ---------------  ----------   ----------------------------------------
 **  any              ROLLBACK     The current transaction is rolled back and
 **                                sqlite3_exec() returns immediately with a
 **                                sqlite3_step() returns immediately with a
 **                                return code of SQLITE_CONSTRAINT.
 **
 **  any              ABORT        Back out changes from the current command
 **                                only (do not do a complete rollback) then
 **                                cause sqlite3_exec() to return immediately
 **                                cause sqlite3_step() to return immediately
 **                                with SQLITE_CONSTRAINT.
 **
 **  any              FAIL         Sqlite3_exec() returns immediately with a
 **  any              FAIL         Sqlite3_step() returns immediately with a
 **                                return code of SQLITE_CONSTRAINT.  The
 **                                transaction is not rolled back and any
 **                                prior changes are retained.
 **                                changes to prior rows are retained.
 **
 **  any              IGNORE       The record number and data is popped from
 **                                the stack and there is an immediate jump
 **                                to label ignoreDest.
 **  any              IGNORE       The attempt in insert or update the current
 **                                row is skipped, without throwing an error.
 **                                Processing continues with the next row.
 **                                (There is an immediate jump to ignoreDest.)
 **
 **  NOT NULL         REPLACE      The NULL value is replace by the default
 **                                value for that column.  If the default value

@@ -93020,44 +94560,59 @@ insert_cleanup:

 ** Or if overrideError==OE_Default, then the pParse->onError parameter
 ** is used.  Or if pParse->onError==OE_Default then the onError value
 ** for the constraint is used.
 **
 ** The calling routine must open a read/write cursor for pTab with
 ** cursor number "baseCur".  All indices of pTab must also have open
 ** read/write cursors with cursor number baseCur+i for the i-th cursor.
 ** Except, if there is no possibility of a REPLACE action then
 ** cursors do not need to be open for indices where aRegIdx[i]==0.
 */
 SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   Parse *pParse,      /* The parser context */
   Table *pTab,        /* the table into which we are inserting */
   int baseCur,        /* Index of a read/write cursor pointing at pTab */
   int regRowid,       /* Index of the range of input registers */
   int *aRegIdx,       /* Register used by each index.  0 for unused indices */
   int rowidChng,      /* True if the rowid might collide with existing entry */
   int isUpdate,       /* True for UPDATE, False for INSERT */
   int overrideError,  /* Override onError to this if not OE_Default */
   int ignoreDest,     /* Jump to this label on an OE_Ignore resolution */
   int *pbMayReplace   /* OUT: Set to true if constraint may cause a replace */
 ){
   int i;              /* loop counter */
   Vdbe *v;            /* VDBE under constrution */
   int nCol;           /* Number of columns */
   int onError;        /* Conflict resolution strategy */
   int j1;             /* Addresss of jump instruction */
   int j2 = 0, j3;     /* Addresses of jump instructions */
   int regData;        /* Register containing first data column */
   int iCur;           /* Table cursor number */
   Parse *pParse,       /* The parser context */
   Table *pTab,         /* The table being inserted or updated */
   int *aRegIdx,        /* Use register aRegIdx[i] for index i.  0 for unused */
   int iDataCur,        /* Canonical data cursor (main table or PK index) */
   int iIdxCur,         /* First index cursor */
   int regNewData,      /* First register in a range holding values to insert */
   int regOldData,      /* Previous content.  0 for INSERTs */
   u8 pkChng,           /* Non-zero if the rowid or PRIMARY KEY changed */
   u8 overrideError,    /* Override onError to this if not OE_Default */
   int ignoreDest,      /* Jump to this label on an OE_Ignore resolution */
   int *pbMayReplace    /* OUT: Set to true if constraint may cause a replace */
 ){
   Vdbe *v;             /* VDBE under constrution */
   Index *pIdx;         /* Pointer to one of the indices */
   Index *pPk = 0;      /* The PRIMARY KEY index */
   sqlite3 *db;         /* Database connection */
   int i;               /* loop counter */
   int ix;              /* Index loop counter */
   int nCol;            /* Number of columns */
   int onError;         /* Conflict resolution strategy */
   int j1;              /* Addresss of jump instruction */
   int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
   int regOldRowid = (rowidChng && isUpdate) ? rowidChng : regRowid;
   int nPkField;        /* Number of fields in PRIMARY KEY. 1 for ROWID tables */
   int ipkTop = 0;      /* Top of the rowid change constraint check */
   int ipkBottom = 0;   /* Bottom of the rowid change constraint check */
   u8 isUpdate;         /* True if this is an UPDATE operation */
   u8 bAffinityDone = 0;  /* True if the OP_Affinity operation has been run */
   int regRowid = -1;   /* Register holding ROWID value */
   isUpdate = regOldData!=0;
   db = pParse->db;
   v = sqlite3GetVdbe(pParse);
   assert( v!=0 );
   assert( pTab->pSelect==0 );  /* This table is not a VIEW */
   nCol = pTab->nCol;
   regData = regRowid + 1;
   /* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for
   ** normal rowid tables.  nPkField is the number of key fields in the
   ** pPk index or 1 for a rowid table.  In other words, nPkField is the
   ** number of fields in the true primary key of the table. */
   if( HasRowid(pTab) ){
     pPk = 0;
     nPkField = 1;
   }else{
     pPk = sqlite3PrimaryKeyIndex(pTab);
     nPkField = pPk->nKeyCol;
   }
   /* Record that this module has started */
   VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)",
                      iDataCur, iIdxCur, regNewData, regOldData, pkChng));
   /* Test all NOT NULL constraints.
   */

@@ -93080,24 +94635,26 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(

     switch( onError ){
       case OE_Abort:
         sqlite3MayAbort(pParse);
         /* Fall through */
       case OE_Rollback:
       case OE_Fail: {
         char *zMsg;
         sqlite3VdbeAddOp3(v, OP_HaltIfNull,
                           SQLITE_CONSTRAINT_NOTNULL, onError, regData+i);
         zMsg = sqlite3MPrintf(db, "%s.%s may not be NULL",
                               pTab->zName, pTab->aCol[i].zName);
         sqlite3VdbeChangeP4(v, -1, zMsg, P4_DYNAMIC);
         char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,
                                     pTab->aCol[i].zName);
         sqlite3VdbeAddOp4(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL, onError,
                           regNewData+1+i, zMsg, P4_DYNAMIC);
         sqlite3VdbeChangeP5(v, P5_ConstraintNotNull);
         VdbeCoverage(v);
         break;
       }
       case OE_Ignore: {
         sqlite3VdbeAddOp2(v, OP_IsNull, regData+i, ignoreDest);
         sqlite3VdbeAddOp2(v, OP_IsNull, regNewData+1+i, ignoreDest);
         VdbeCoverage(v);
         break;
       }
       default: {
         assert( onError==OE_Replace );
         j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regData+i);
         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regData+i);
         j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regNewData+1+i); VdbeCoverage(v);
         sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regNewData+1+i);
         sqlite3VdbeJumpHere(v, j1);
         break;
       }

@@ -93109,7 +94666,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(

 #ifndef SQLITE_OMIT_CHECK
   if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
     ExprList *pCheck = pTab->pCheck;
     pParse->ckBase = regData;
     pParse->ckBase = regNewData+1;
     onError = overrideError!=OE_Default ? overrideError : OE_Abort;
     for(i=0; i<pCheck->nExpr; i++){
       int allOk = sqlite3VdbeMakeLabel(v);

@@ -93117,37 +94674,61 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(

       if( onError==OE_Ignore ){
         sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
       }else{
         char *zConsName = pCheck->a[i].zName;
         char *zName = pCheck->a[i].zName;
         if( zName==0 ) zName = pTab->zName;
         if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-15569-63625 */
         if( zConsName ){
           zConsName = sqlite3MPrintf(db, "constraint %s failed", zConsName);
         }else{
           zConsName = 0;
         }
         sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK,
                               onError, zConsName, P4_DYNAMIC);
                               onError, zName, P4_TRANSIENT,
                               P5_ConstraintCheck);
       }
       sqlite3VdbeResolveLabel(v, allOk);
     }
   }
 #endif /* !defined(SQLITE_OMIT_CHECK) */
   /* If we have an INTEGER PRIMARY KEY, make sure the primary key
   ** of the new record does not previously exist.  Except, if this
   ** is an UPDATE and the primary key is not changing, that is OK.
   /* If rowid is changing, make sure the new rowid does not previously
   ** exist in the table.
   */
   if( rowidChng ){
   if( pkChng && pPk==0 ){
     int addrRowidOk = sqlite3VdbeMakeLabel(v);
     /* Figure out what action to take in case of a rowid collision */
     onError = pTab->keyConf;
     if( overrideError!=OE_Default ){
       onError = overrideError;
     }else if( onError==OE_Default ){
       onError = OE_Abort;
     }
     if( isUpdate ){
       j2 = sqlite3VdbeAddOp3(v, OP_Eq, regRowid, 0, rowidChng);
       /* pkChng!=0 does not mean that the rowid has change, only that
       ** it might have changed.  Skip the conflict logic below if the rowid
       ** is unchanged. */
       sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData);
       sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
       VdbeCoverage(v);
     }
     /* If the response to a rowid conflict is REPLACE but the response
     ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
     ** to defer the running of the rowid conflict checking until after
     ** the UNIQUE constraints have run.
     */
     if( onError==OE_Replace && overrideError!=OE_Replace ){
       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
         if( pIdx->onError==OE_Ignore || pIdx->onError==OE_Fail ){
           ipkTop = sqlite3VdbeAddOp0(v, OP_Goto);
           break;
         }
       }
     }
     j3 = sqlite3VdbeAddOp3(v, OP_NotExists, baseCur, 0, regRowid);
     /* Check to see if the new rowid already exists in the table.  Skip
     ** the following conflict logic if it does not. */
     sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData);
     VdbeCoverage(v);
     /* Generate code that deals with a rowid collision */
     switch( onError ){
       default: {
         onError = OE_Abort;

@@ -93156,8 +94737,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(

       case OE_Rollback:
       case OE_Abort:
       case OE_Fail: {
         sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_PRIMARYKEY,
            onError, "PRIMARY KEY must be unique", P4_STATIC);
         sqlite3RowidConstraint(pParse, onError, pTab);
         break;
       }
       case OE_Replace: {

@@ -93189,68 +94769,93 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(

         }
         if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){
           sqlite3MultiWrite(pParse);
           sqlite3GenerateRowDelete(
               pParse, pTab, baseCur, regRowid, 0, pTrigger, OE_Replace
           );
           sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
                                    regNewData, 1, 0, OE_Replace, 1);
         }else if( pTab->pIndex ){
           sqlite3MultiWrite(pParse);
           sqlite3GenerateRowIndexDelete(pParse, pTab, baseCur, 0);
           sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, 0);
         }
         seenReplace = 1;
         break;
       }
       case OE_Ignore: {
         assert( seenReplace==0 );
         /*assert( seenReplace==0 );*/
         sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
         break;
       }
     }
     sqlite3VdbeJumpHere(v, j3);
     if( isUpdate ){
       sqlite3VdbeJumpHere(v, j2);
     sqlite3VdbeResolveLabel(v, addrRowidOk);
     if( ipkTop ){
       ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
       sqlite3VdbeJumpHere(v, ipkTop);
     }
   }
   /* Test all UNIQUE constraints by creating entries for each UNIQUE
   ** index and making sure that duplicate entries do not already exist.
   ** Add the new records to the indices as we go.
   ** Compute the revised record entries for indices as we go.
   **
   ** This loop also handles the case of the PRIMARY KEY index for a
   ** WITHOUT ROWID table.
   */
   for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
     int regIdx;
     int regR;
     int addrSkipRow = 0;
   for(ix=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, ix++){
     int regIdx;          /* Range of registers hold conent for pIdx */
     int regR;            /* Range of registers holding conflicting PK */
     int iThisCur;        /* Cursor for this UNIQUE index */
     int addrUniqueOk;    /* Jump here if the UNIQUE constraint is satisfied */
     if( aRegIdx[iCur]==0 ) continue;  /* Skip unused indices */
     if( aRegIdx[ix]==0 ) continue;  /* Skip indices that do not change */
     if( bAffinityDone==0 ){
       sqlite3TableAffinity(v, pTab, regNewData+1);
       bAffinityDone = 1;
     }
     iThisCur = iIdxCur+ix;
     addrUniqueOk = sqlite3VdbeMakeLabel(v);
     /* Skip partial indices for which the WHERE clause is not true */
     if( pIdx->pPartIdxWhere ){
       sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[iCur]);
       addrSkipRow = sqlite3VdbeMakeLabel(v);
       pParse->ckBase = regData;
       sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, addrSkipRow,
       sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]);
       pParse->ckBase = regNewData+1;
       sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
                          SQLITE_JUMPIFNULL);
       pParse->ckBase = 0;
     }
     /* Create a key for accessing the index entry */
     regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn+1);
     /* Create a record for this index entry as it should appear after
     ** the insert or update.  Store that record in the aRegIdx[ix] register
     */
     regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn);
     for(i=0; i<pIdx->nColumn; i++){
       int idx = pIdx->aiColumn[i];
       if( idx==pTab->iPKey ){
         sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
       int iField = pIdx->aiColumn[i];
       int x;
       if( iField<0 || iField==pTab->iPKey ){
         if( regRowid==regIdx+i ) continue; /* ROWID already in regIdx+i */
         x = regNewData;
         regRowid =  pIdx->pPartIdxWhere ? -1 : regIdx+i;
       }else{
         sqlite3VdbeAddOp2(v, OP_SCopy, regData+idx, regIdx+i);
         x = iField + regNewData + 1;
       }
       sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i);
       VdbeComment((v, "%s", iField<0 ? "rowid" : pTab->aCol[iField].zName));
     }
     sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
     VdbeComment((v, "for %s", pIdx->zName));
     sqlite3ExprCacheAffinityChange(pParse, regIdx, pIdx->nColumn);
     /* In an UPDATE operation, if this index is the PRIMARY KEY index
     ** of a WITHOUT ROWID table and there has been no change the
     ** primary key, then no collision is possible.  The collision detection
     ** logic below can all be skipped. */
     if( isUpdate && pPk==pIdx && pkChng==0 ){
       sqlite3VdbeResolveLabel(v, addrUniqueOk);
       continue;
     }
     sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
     sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn+1, aRegIdx[iCur]);
     sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v, pIdx), P4_TRANSIENT);
     sqlite3ExprCacheAffinityChange(pParse, regIdx, pIdx->nColumn+1);
     /* Find out what action to take in case there is an indexing conflict */
     /* Find out what action to take in case there is a uniqueness conflict */
     onError = pIdx->onError;
     if( onError==OE_None ){
       sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
       sqlite3VdbeResolveLabel(v, addrSkipRow);
       sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn);
       sqlite3VdbeResolveLabel(v, addrUniqueOk);
       continue;  /* pIdx is not a UNIQUE index */
     }
     if( overrideError!=OE_Default ){

@@ -93258,18 +94863,64 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(

     }else if( onError==OE_Default ){
       onError = OE_Abort;
     }
     if( seenReplace ){
       if( onError==OE_Ignore ) onError = OE_Replace;
       else if( onError==OE_Fail ) onError = OE_Abort;
     }
     /* Check to see if the new index entry will be unique */
     regR = sqlite3GetTempReg(pParse);
     sqlite3VdbeAddOp2(v, OP_SCopy, regOldRowid, regR);
     j3 = sqlite3VdbeAddOp4(v, OP_IsUnique, baseCur+iCur+1, 0,
                            regR, SQLITE_INT_TO_PTR(regIdx),
                            P4_INT32);
     sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
     sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
                          regIdx, pIdx->nKeyCol); VdbeCoverage(v);
     /* Generate code to handle collisions */
     regR = (pIdx==pPk) ? regIdx : sqlite3GetTempRange(pParse, nPkField);
     if( isUpdate || onError==OE_Replace ){
       if( HasRowid(pTab) ){
         sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR);
         /* Conflict only if the rowid of the existing index entry
         ** is different from old-rowid */
         if( isUpdate ){
           sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData);
           sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
           VdbeCoverage(v);
         }
       }else{
         int x;
         /* Extract the PRIMARY KEY from the end of the index entry and
         ** store it in registers regR..regR+nPk-1 */
         if( pIdx!=pPk ){
           for(i=0; i<pPk->nKeyCol; i++){
             x = sqlite3ColumnOfIndex(pIdx, pPk->aiColumn[i]);
             sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i);
             VdbeComment((v, "%s.%s", pTab->zName,
                          pTab->aCol[pPk->aiColumn[i]].zName));
           }
         }
         if( isUpdate ){
           /* If currently processing the PRIMARY KEY of a WITHOUT ROWID
           ** table, only conflict if the new PRIMARY KEY values are actually
           ** different from the old.
           **
           ** For a UNIQUE index, only conflict if the PRIMARY KEY values
           ** of the matched index row are different from the original PRIMARY
           ** KEY values of this row before the update.  */
           int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol;
           int op = OP_Ne;
           int regCmp = (pIdx->autoIndex==2 ? regIdx : regR);
           for(i=0; i<pPk->nKeyCol; i++){
             char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]);
             x = pPk->aiColumn[i];
             if( i==(pPk->nKeyCol-1) ){
               addrJump = addrUniqueOk;
               op = OP_Eq;
             }
             sqlite3VdbeAddOp4(v, op,
                 regOldData+1+x, addrJump, regCmp+i, p4, P4_COLLSEQ
             );
             sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
             VdbeCoverageIf(v, op==OP_Eq);
             VdbeCoverageIf(v, op==OP_Ne);
           }
         }
       }
     }
     /* Generate code that executes if the new index entry is not unique */
     assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail

@@ -93278,30 +94929,10 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(

       case OE_Rollback:
       case OE_Abort:
       case OE_Fail: {
         int j;
         StrAccum errMsg;
         const char *zSep;
         char *zErr;
         sqlite3StrAccumInit(&errMsg, 0, 0, 200);
         errMsg.db = db;
         zSep = pIdx->nColumn>1 ? "columns " : "column ";
         for(j=0; j<pIdx->nColumn; j++){
           char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
           sqlite3StrAccumAppend(&errMsg, zSep, -1);
           zSep = ", ";
           sqlite3StrAccumAppend(&errMsg, zCol, -1);
         }
         sqlite3StrAccumAppend(&errMsg,
             pIdx->nColumn>1 ? " are not unique" : " is not unique", -1);
         zErr = sqlite3StrAccumFinish(&errMsg);
         sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_UNIQUE,
                               onError, zErr, 0);
         sqlite3DbFree(errMsg.db, zErr);
         sqlite3UniqueConstraint(pParse, onError, pIdx);
         break;
       }
       case OE_Ignore: {
         assert( seenReplace==0 );
         sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
         break;
       }

@@ -93312,27 +94943,29 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(

         if( db->flags&SQLITE_RecTriggers ){
           pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
         }
         sqlite3GenerateRowDelete(
             pParse, pTab, baseCur, regR, 0, pTrigger, OE_Replace
         );
         sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
                                  regR, nPkField, 0, OE_Replace, pIdx==pPk);
         seenReplace = 1;
         break;
       }
     }
     sqlite3VdbeJumpHere(v, j3);
     sqlite3VdbeResolveLabel(v, addrSkipRow);
     sqlite3ReleaseTempReg(pParse, regR);
     sqlite3VdbeResolveLabel(v, addrUniqueOk);
     sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn);
     if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField);
   }
   if( pbMayReplace ){
     *pbMayReplace = seenReplace;
   if( ipkTop ){
     sqlite3VdbeAddOp2(v, OP_Goto, 0, ipkTop+1);
     sqlite3VdbeJumpHere(v, ipkBottom);
   }
   *pbMayReplace = seenReplace;
   VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace));
 }
 /*
 ** This routine generates code to finish the INSERT or UPDATE operation
 ** that was started by a prior call to sqlite3GenerateConstraintChecks.
 ** A consecutive range of registers starting at regRowid contains the
 ** A consecutive range of registers starting at regNewData contains the
 ** rowid and the content to be inserted.
 **
 ** The arguments to this routine should be the same as the first six

@@ -93341,37 +94974,46 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(

 SQLITE_PRIVATE void sqlite3CompleteInsertion(
   Parse *pParse,      /* The parser context */
   Table *pTab,        /* the table into which we are inserting */
   int baseCur,        /* Index of a read/write cursor pointing at pTab */
   int regRowid,       /* Range of content */
   int iDataCur,       /* Cursor of the canonical data source */
   int iIdxCur,        /* First index cursor */
   int regNewData,     /* Range of content */
   int *aRegIdx,       /* Register used by each index.  0 for unused indices */
   int isUpdate,       /* True for UPDATE, False for INSERT */
   int appendBias,     /* True if this is likely to be an append */
   int useSeekResult   /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
 ){
   int i;
   Vdbe *v;
   Index *pIdx;
   u8 pik_flags;
   int regData;
   int regRec;
   Vdbe *v;            /* Prepared statements under construction */
   Index *pIdx;        /* An index being inserted or updated */
   u8 pik_flags;       /* flag values passed to the btree insert */
   int regData;        /* Content registers (after the rowid) */
   int regRec;         /* Register holding assemblied record for the table */
   int i;              /* Loop counter */
   u8 bAffinityDone = 0; /* True if OP_Affinity has been run already */
   v = sqlite3GetVdbe(pParse);
   assert( v!=0 );
   assert( pTab->pSelect==0 );  /* This table is not a VIEW */
   for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
     if( aRegIdx[i]==0 ) continue;
     bAffinityDone = 1;
     if( pIdx->pPartIdxWhere ){
       sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2);
       VdbeCoverage(v);
     }
     sqlite3VdbeAddOp2(v, OP_IdxInsert, baseCur+i+1, aRegIdx[i]);
     if( useSeekResult ){
       sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
     sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i]);
     pik_flags = 0;
     if( useSeekResult ) pik_flags = OPFLAG_USESEEKRESULT;
     if( pIdx->autoIndex==2 && !HasRowid(pTab) ){
       assert( pParse->nested==0 );
       pik_flags |= OPFLAG_NCHANGE;
     }
     if( pik_flags )  sqlite3VdbeChangeP5(v, pik_flags);
   }
   regData = regRowid + 1;
   if( !HasRowid(pTab) ) return;
   regData = regNewData + 1;
   regRec = sqlite3GetTempReg(pParse);
   sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
   sqlite3TableAffinityStr(v, pTab);
   if( !bAffinityDone ) sqlite3TableAffinity(v, pTab, 0);
   sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
   if( pParse->nested ){
     pik_flags = 0;

@@ -93385,7 +95027,7 @@ SQLITE_PRIVATE void sqlite3CompleteInsertion(

   if( useSeekResult ){
     pik_flags |= OPFLAG_USESEEKRESULT;
   }
   sqlite3VdbeAddOp3(v, OP_Insert, baseCur, regRec, regRowid);
   sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, regRec, regNewData);
   if( !pParse->nested ){
     sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
   }

@@ -93393,39 +95035,71 @@ SQLITE_PRIVATE void sqlite3CompleteInsertion(

 }
 /*
 ** Generate code that will open cursors for a table and for all
 ** indices of that table.  The "baseCur" parameter is the cursor number used
 ** for the table.  Indices are opened on subsequent cursors.
 ** Allocate cursors for the pTab table and all its indices and generate
 ** code to open and initialized those cursors.
 **
 ** The cursor for the object that contains the complete data (normally
 ** the table itself, but the PRIMARY KEY index in the case of a WITHOUT
 ** ROWID table) is returned in *piDataCur.  The first index cursor is
 ** returned in *piIdxCur.  The number of indices is returned.
 **
 ** Return the number of indices on the table.
 ** Use iBase as the first cursor (either the *piDataCur for rowid tables
 ** or the first index for WITHOUT ROWID tables) if it is non-negative.
 ** If iBase is negative, then allocate the next available cursor.
 **
 ** For a rowid table, *piDataCur will be exactly one less than *piIdxCur.
 ** For a WITHOUT ROWID table, *piDataCur will be somewhere in the range
 ** of *piIdxCurs, depending on where the PRIMARY KEY index appears on the
 ** pTab->pIndex list.
 */
 SQLITE_PRIVATE int sqlite3OpenTableAndIndices(
   Parse *pParse,   /* Parsing context */
   Table *pTab,     /* Table to be opened */
   int baseCur,     /* Cursor number assigned to the table */
   int op           /* OP_OpenRead or OP_OpenWrite */
   int op,          /* OP_OpenRead or OP_OpenWrite */
   int iBase,       /* Use this for the table cursor, if there is one */
   u8 *aToOpen,     /* If not NULL: boolean for each table and index */
   int *piDataCur,  /* Write the database source cursor number here */
   int *piIdxCur    /* Write the first index cursor number here */
 ){
   int i;
   int iDb;
   int iDataCur;
   Index *pIdx;
   Vdbe *v;
   if( IsVirtual(pTab) ) return 0;
   assert( op==OP_OpenRead || op==OP_OpenWrite );
   if( IsVirtual(pTab) ){
     assert( aToOpen==0 );
     *piDataCur = 0;
     *piIdxCur = 1;
     return 0;
   }
   iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
   v = sqlite3GetVdbe(pParse);
   assert( v!=0 );
   sqlite3OpenTable(pParse, baseCur, iDb, pTab, op);
   for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
     KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
     assert( pIdx->pSchema==pTab->pSchema );
     sqlite3VdbeAddOp4(v, op, i+baseCur, pIdx->tnum, iDb,
                       (char*)pKey, P4_KEYINFO_HANDOFF);
     VdbeComment((v, "%s", pIdx->zName));
   if( iBase<0 ) iBase = pParse->nTab;
   iDataCur = iBase++;
   if( piDataCur ) *piDataCur = iDataCur;
   if( HasRowid(pTab) && (aToOpen==0 || aToOpen[0]) ){
     sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
   }else{
     sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
   }
   if( pParse->nTab<baseCur+i ){
     pParse->nTab = baseCur+i;
   if( piIdxCur ) *piIdxCur = iBase;
   for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
     int iIdxCur = iBase++;
     assert( pIdx->pSchema==pTab->pSchema );
     if( pIdx->autoIndex==2 && !HasRowid(pTab) && piDataCur ){
       *piDataCur = iIdxCur;
     }
     if( aToOpen==0 || aToOpen[i+1] ){
       sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
       sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
       VdbeComment((v, "%s", pIdx->zName));
     }
   }
   return i-1;
   if( iBase>pParse->nTab ) pParse->nTab = iBase;
   return i;
 }

@@ -93470,13 +95144,13 @@ static int xferCompatibleIndex(Index *pDest, Index *pSrc){

   int i;
   assert( pDest && pSrc );
   assert( pDest->pTable!=pSrc->pTable );
   if( pDest->nColumn!=pSrc->nColumn ){
   if( pDest->nKeyCol!=pSrc->nKeyCol ){
     return 0;   /* Different number of columns */
   }
   if( pDest->onError!=pSrc->onError ){
     return 0;   /* Different conflict resolution strategies */
   }
   for(i=0; i<pSrc->nColumn; i++){
   for(i=0; i<pSrc->nKeyCol; i++){
     if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
       return 0;   /* Different columns indexed */
     }

@@ -93535,10 +95209,9 @@ static int xferOptimization(

   int iDbSrc;                      /* The database of pSrc */
   int iSrc, iDest;                 /* Cursors from source and destination */
   int addr1, addr2;                /* Loop addresses */
   int emptyDestTest;               /* Address of test for empty pDest */
   int emptySrcTest;                /* Address of test for empty pSrc */
   int emptyDestTest = 0;           /* Address of test for empty pDest */
   int emptySrcTest = 0;            /* Address of test for empty pSrc */
   Vdbe *v;                         /* The VDBE we are building */
   KeyInfo *pKey;                   /* Key information for an index */
   int regAutoinc;                  /* Memory register used by AUTOINC */
   int destHasUniqueIdx = 0;        /* True if pDest has a UNIQUE index */
   int regData, regRowid;           /* Registers holding data and rowid */

@@ -93546,6 +95219,12 @@ static int xferOptimization(

   if( pSelect==0 ){
     return 0;   /* Must be of the form  INSERT INTO ... SELECT ... */
   }
   if( pParse->pWith || pSelect->pWith ){
     /* Do not attempt to process this query if there are an WITH clauses
     ** attached to it. Proceeding may generate a false "no such table: xxx"
     ** error if pSelect reads from a CTE named "xxx".  */
     return 0;
   }
   if( sqlite3TriggerList(pParse, pDest) ){
     return 0;   /* tab1 must not have triggers */
   }

@@ -93608,6 +95287,9 @@ static int xferOptimization(

   if( pSrc==pDest ){
     return 0;   /* tab1 and tab2 may not be the same table */
   }
   if( HasRowid(pDest)!=HasRowid(pSrc) ){
     return 0;   /* source and destination must both be WITHOUT ROWID or not */
   }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   if( pSrc->tabFlags & TF_Virtual ){
     return 0;   /* tab2 must not be a virtual table */

@@ -93678,7 +95360,10 @@ static int xferOptimization(

   iSrc = pParse->nTab++;
   iDest = pParse->nTab++;
   regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
   regData = sqlite3GetTempReg(pParse);
   regRowid = sqlite3GetTempReg(pParse);
   sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
   assert( HasRowid(pDest) || destHasUniqueIdx );
   if( (pDest->iPKey<0 && pDest->pIndex!=0)          /* (1) */
    || destHasUniqueIdx                              /* (2) */
    || (onError!=OE_Abort && onError!=OE_Rollback)   /* (3) */

@@ -93697,61 +95382,60 @@ static int xferOptimization(

     **
     ** (3) onError is something other than OE_Abort and OE_Rollback.
     */
     addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0);
     addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v);
     emptyDestTest = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
     sqlite3VdbeJumpHere(v, addr1);
   }else{
     emptyDestTest = 0;
   }
   sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
   emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
   regData = sqlite3GetTempReg(pParse);
   regRowid = sqlite3GetTempReg(pParse);
   if( pDest->iPKey>=0 ){
     addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
     addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
     sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_PRIMARYKEY,
         onError, "PRIMARY KEY must be unique", P4_STATIC);
     sqlite3VdbeJumpHere(v, addr2);
     autoIncStep(pParse, regAutoinc, regRowid);
   }else if( pDest->pIndex==0 ){
     addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
   if( HasRowid(pSrc) ){
     sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
     emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
     if( pDest->iPKey>=0 ){
       addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
       addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
       VdbeCoverage(v);
       sqlite3RowidConstraint(pParse, onError, pDest);
       sqlite3VdbeJumpHere(v, addr2);
       autoIncStep(pParse, regAutoinc, regRowid);
     }else if( pDest->pIndex==0 ){
       addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
     }else{
       addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
       assert( (pDest->tabFlags & TF_Autoincrement)==0 );
     }
     sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
     sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
     sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND);
     sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
     sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
     sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
   }else{
     addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
     assert( (pDest->tabFlags & TF_Autoincrement)==0 );
     sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
     sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
   }
   sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
   sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
   sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND);
   sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
   sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1);
   for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
     for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
       if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
     }
     assert( pSrcIdx );
     sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
     sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
     pKey = sqlite3IndexKeyinfo(pParse, pSrcIdx);
     sqlite3VdbeAddOp4(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc,
                       (char*)pKey, P4_KEYINFO_HANDOFF);
     sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc);
     sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx);
     VdbeComment((v, "%s", pSrcIdx->zName));
     pKey = sqlite3IndexKeyinfo(pParse, pDestIdx);
     sqlite3VdbeAddOp4(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest,
                       (char*)pKey, P4_KEYINFO_HANDOFF);
     sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest);
     sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx);
     sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR);
     VdbeComment((v, "%s", pDestIdx->zName));
     addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
     addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_RowKey, iSrc, regData);
     sqlite3VdbeAddOp3(v, OP_IdxInsert, iDest, regData, 1);
     sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1);
     sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
     sqlite3VdbeJumpHere(v, addr1);
     sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
     sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
   }
   sqlite3VdbeJumpHere(v, emptySrcTest);
   if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest);
   sqlite3ReleaseTempReg(pParse, regRowid);
   sqlite3ReleaseTempReg(pParse, regData);
   sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
   sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
   if( emptyDestTest ){
     sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
     sqlite3VdbeJumpHere(v, emptyDestTest);

@@ -95253,12 +96937,14 @@ static const struct sPragmaNames {

     /* ePragFlag: */ PragFlag_NeedSchema,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 #if !defined(SQLITE_OMIT_AUTOMATIC_INDEX)
   { /* zName:     */ "automatic_index",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_AutoIndex },
 #endif
 #endif
   { /* zName:     */ "busy_timeout",
     /* ePragTyp:  */ PragTyp_BUSY_TIMEOUT,
     /* ePragFlag: */ 0,

@@ -95269,18 +96955,22 @@ static const struct sPragmaNames {

     /* ePragFlag: */ PragFlag_NeedSchema,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "cache_spill",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_CacheSpill },
 #endif
   { /* zName:     */ "case_sensitive_like",
     /* ePragTyp:  */ PragTyp_CASE_SENSITIVE_LIKE,
     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "checkpoint_fullfsync",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_CkptFullFSync },
 #endif
 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
   { /* zName:     */ "collation_list",
     /* ePragTyp:  */ PragTyp_COLLATION_LIST,

@@ -95293,10 +96983,12 @@ static const struct sPragmaNames {

     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "count_changes",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_CountRows },
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_OS_WIN
   { /* zName:     */ "data_store_directory",
     /* ePragTyp:  */ PragTyp_DATA_STORE_DIRECTORY,

@@ -95315,16 +97007,20 @@ static const struct sPragmaNames {

     /* ePragFlag: */ PragFlag_NeedSchema,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
   { /* zName:     */ "defer_foreign_keys",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_DeferFKs },
 #endif
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "empty_result_callbacks",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_NullCallback },
 #endif
 #if !defined(SQLITE_OMIT_UTF16)
   { /* zName:     */ "encoding",
     /* ePragTyp:  */ PragTyp_ENCODING,

@@ -95343,18 +97039,21 @@ static const struct sPragmaNames {

     /* ePragFlag: */ PragFlag_NeedSchema,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
   { /* zName:     */ "foreign_keys",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_ForeignKeys },
 #endif
 #endif
 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
   { /* zName:     */ "freelist_count",
     /* ePragTyp:  */ PragTyp_HEADER_VALUE,
     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "full_column_names",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,

@@ -95363,6 +97062,7 @@ static const struct sPragmaNames {

     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_FullFSync },
 #endif
 #if defined(SQLITE_HAS_CODEC)
   { /* zName:     */ "hexkey",
     /* ePragTyp:  */ PragTyp_HEXKEY,

@@ -95373,12 +97073,14 @@ static const struct sPragmaNames {

     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 #if !defined(SQLITE_OMIT_CHECK)
   { /* zName:     */ "ignore_check_constraints",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_IgnoreChecks },
 #endif
 #endif
 #if !defined(SQLITE_OMIT_AUTOVACUUM)
   { /* zName:     */ "incremental_vacuum",
     /* ePragTyp:  */ PragTyp_INCREMENTAL_VACUUM,

@@ -95417,10 +97119,12 @@ static const struct sPragmaNames {

     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "legacy_file_format",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_LegacyFileFmt },
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE
   { /* zName:     */ "lock_proxy_file",
     /* ePragTyp:  */ PragTyp_LOCK_PROXY_FILE,

@@ -95461,16 +97165,19 @@ static const struct sPragmaNames {

     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "query_only",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_QueryOnly },
 #endif
 #if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
   { /* zName:     */ "quick_check",
     /* ePragTyp:  */ PragTyp_INTEGRITY_CHECK,
     /* ePragFlag: */ PragFlag_NeedSchema,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "read_uncommitted",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,

@@ -95479,16 +97186,19 @@ static const struct sPragmaNames {

     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_RecTriggers },
 #endif
 #if defined(SQLITE_HAS_CODEC)
   { /* zName:     */ "rekey",
     /* ePragTyp:  */ PragTyp_REKEY,
     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "reverse_unordered_selects",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_ReverseOrder },
 #endif
 #if !defined(SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS)
   { /* zName:     */ "schema_version",
     /* ePragTyp:  */ PragTyp_HEADER_VALUE,

@@ -95501,10 +97211,12 @@ static const struct sPragmaNames {

     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "short_column_names",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_ShortColNames },
 #endif
   { /* zName:     */ "shrink_memory",
     /* ePragTyp:  */ PragTyp_SHRINK_MEMORY,
     /* ePragFlag: */ 0,

@@ -95513,12 +97225,14 @@ static const struct sPragmaNames {

     /* ePragTyp:  */ PragTyp_SOFT_HEAP_LIMIT,
     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 #if defined(SQLITE_DEBUG)
   { /* zName:     */ "sql_trace",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_SqlTrace },
 #endif
 #endif
 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
   { /* zName:     */ "stats",
     /* ePragTyp:  */ PragTyp_STATS,

@@ -95553,6 +97267,7 @@ static const struct sPragmaNames {

     /* ePragFlag: */ 0,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
 #if defined(SQLITE_DEBUG)
   { /* zName:     */ "vdbe_addoptrace",
     /* ePragTyp:  */ PragTyp_FLAG,

@@ -95562,6 +97277,10 @@ static const struct sPragmaNames {

     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_SqlTrace|SQLITE_VdbeListing|SQLITE_VdbeTrace },
   { /* zName:     */ "vdbe_eqp",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_VdbeEQP },
   { /* zName:     */ "vdbe_listing",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,

@@ -95571,6 +97290,7 @@ static const struct sPragmaNames {

     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_VdbeTrace },
 #endif
 #endif
 #if !defined(SQLITE_OMIT_WAL)
   { /* zName:     */ "wal_autocheckpoint",
     /* ePragTyp:  */ PragTyp_WAL_AUTOCHECKPOINT,

@@ -95581,12 +97301,14 @@ static const struct sPragmaNames {

     /* ePragFlag: */ PragFlag_NeedSchema,
     /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
   { /* zName:     */ "writable_schema",
     /* ePragTyp:  */ PragTyp_FLAG,
     /* ePragFlag: */ 0,
     /* iArg:      */ SQLITE_WriteSchema|SQLITE_RecoveryMode },
 #endif
 };
 /* Number of pragmas: 56 on by default, 68 total. */
 /* Number of pragmas: 56 on by default, 69 total. */
 /* End of the automatically generated pragma table.
 ***************************************************************************/

@@ -95945,6 +97667,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

   ** size of historical compatibility.
   */
   case PragTyp_DEFAULT_CACHE_SIZE: {
     static const int iLn = VDBE_OFFSET_LINENO(2);
     static const VdbeOpList getCacheSize[] = {
       { OP_Transaction, 0, 0,        0},                         /* 0 */
       { OP_ReadCookie,  0, 1,        BTREE_DEFAULT_CACHE_SIZE},  /* 1 */

@@ -95962,7 +97685,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

       sqlite3VdbeSetNumCols(v, 1);
       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", SQLITE_STATIC);
       pParse->nMem += 2;
       addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
       addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize,iLn);
       sqlite3VdbeChangeP1(v, addr, iDb);
       sqlite3VdbeChangeP1(v, addr+1, iDb);
       sqlite3VdbeChangeP1(v, addr+6, SQLITE_DEFAULT_CACHE_SIZE);

@@ -96207,6 +97930,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

         ** file. Before writing to meta[6], check that meta[3] indicates
         ** that this really is an auto-vacuum capable database.
         */
         static const int iLn = VDBE_OFFSET_LINENO(2);
         static const VdbeOpList setMeta6[] = {
           { OP_Transaction,    0,         1,                 0},    /* 0 */
           { OP_ReadCookie,     0,         1,         BTREE_LARGEST_ROOT_PAGE},

@@ -96216,7 +97940,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

           { OP_SetCookie,      0,         BTREE_INCR_VACUUM, 1},    /* 5 */
         };
         int iAddr;
         iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);
         iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn);
         sqlite3VdbeChangeP1(v, iAddr, iDb);
         sqlite3VdbeChangeP1(v, iAddr+1, iDb);
         sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);

@@ -96242,10 +97966,10 @@ SQLITE_PRIVATE void sqlite3Pragma(

     }
     sqlite3BeginWriteOperation(pParse, 0, iDb);
     sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
     addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb);
     addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
     sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
     sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
     sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr);
     sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); VdbeCoverage(v);
     sqlite3VdbeJumpHere(v, addr);
     break;
   }

@@ -96550,8 +98274,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

       int i, k;
       int nHidden = 0;
       Column *pCol;
       Index *pPk;
       for(pPk=pTab->pIndex; pPk && pPk->autoIndex!=2; pPk=pPk->pNext){}
       Index *pPk = sqlite3PrimaryKeyIndex(pTab);
       sqlite3VdbeSetNumCols(v, 6);
       pParse->nMem = 6;
       sqlite3CodeVerifySchema(pParse, iDb);

@@ -96634,8 +98357,8 @@ SQLITE_PRIVATE void sqlite3Pragma(

       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", SQLITE_STATIC);
       sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", SQLITE_STATIC);
       sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", SQLITE_STATIC);
       for(i=0; i<pIdx->nColumn; i++){
         int cnum = pIdx->aiColumn[i];
       for(i=0; i<pIdx->nKeyCol; i++){
         i16 cnum = pIdx->aiColumn[i];
         sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
         sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2);
         assert( pTab->nCol>cnum );

@@ -96806,9 +98529,8 @@ SQLITE_PRIVATE void sqlite3Pragma(

           if( pIdx==0 ){
             sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
           }else{
             KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
             sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
             sqlite3VdbeChangeP4(v, -1, (char*)pKey, P4_KEYINFO_HANDOFF);
             sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
           }
         }else{
           k = 0;

@@ -96818,7 +98540,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

       assert( pParse->nErr>0 || pFK==0 );
       if( pFK ) break;
       if( pParse->nTab<i ) pParse->nTab = i;
       addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0);
       addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v);
       for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
         pParent = sqlite3FindTable(db, pFK->zTo, zDb);
         pIdx = 0;

@@ -96834,26 +98556,26 @@ SQLITE_PRIVATE void sqlite3Pragma(

           if( iKey!=pTab->iPKey ){
             sqlite3VdbeAddOp3(v, OP_Column, 0, iKey, regRow);
             sqlite3ColumnDefault(v, pTab, iKey, regRow);
             sqlite3VdbeAddOp2(v, OP_IsNull, regRow, addrOk);
             sqlite3VdbeAddOp2(v, OP_MustBeInt, regRow,
                sqlite3VdbeCurrentAddr(v)+3);
             sqlite3VdbeAddOp2(v, OP_IsNull, regRow, addrOk); VdbeCoverage(v);
             sqlite3VdbeAddOp2(v, OP_MustBeInt, regRow,
                sqlite3VdbeCurrentAddr(v)+3); VdbeCoverage(v);
           }else{
             sqlite3VdbeAddOp2(v, OP_Rowid, 0, regRow);
           }
           sqlite3VdbeAddOp3(v, OP_NotExists, i, 0, regRow);
           sqlite3VdbeAddOp3(v, OP_NotExists, i, 0, regRow); VdbeCoverage(v);
           sqlite3VdbeAddOp2(v, OP_Goto, 0, addrOk);
           sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
         }else{
           for(j=0; j<pFK->nCol; j++){
             sqlite3ExprCodeGetColumnOfTable(v, pTab, 0,
                             aiCols ? aiCols[j] : pFK->aCol[j].iFrom, regRow+j);
             sqlite3VdbeAddOp2(v, OP_IsNull, regRow+j, addrOk);
             sqlite3VdbeAddOp2(v, OP_IsNull, regRow+j, addrOk); VdbeCoverage(v);
           }
           if( pParent ){
             sqlite3VdbeAddOp3(v, OP_MakeRecord, regRow, pFK->nCol, regKey);
             sqlite3VdbeChangeP4(v, -1,
                      sqlite3IndexAffinityStr(v,pIdx), P4_TRANSIENT);
             sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, pFK->nCol, regKey,
                               sqlite3IndexAffinityStr(v,pIdx), pFK->nCol);
             sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regKey, 0);
             VdbeCoverage(v);
           }
         }
         sqlite3VdbeAddOp2(v, OP_Rowid, 0, regResult+1);

@@ -96864,7 +98586,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

         sqlite3VdbeResolveLabel(v, addrOk);
         sqlite3DbFree(db, aiCols);
       }
       sqlite3VdbeAddOp2(v, OP_Next, 0, addrTop+1);
       sqlite3VdbeAddOp2(v, OP_Next, 0, addrTop+1); VdbeCoverage(v);
       sqlite3VdbeJumpHere(v, addrTop);
     }
   }

@@ -96911,6 +98633,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

     ** messages have been generated, output OK.  Otherwise output the
     ** error message
     */
     static const int iLn = VDBE_OFFSET_LINENO(2);
     static const VdbeOpList endCode[] = {
       { OP_AddImm,      1, 0,        0},    /* 0 */
       { OP_IfNeg,       1, 0,        0},    /* 1 */

@@ -96959,6 +98682,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

       sqlite3CodeVerifySchema(pParse, i);
       addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
       VdbeCoverage(v);
       sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
       sqlite3VdbeJumpHere(v, addr);

@@ -96972,21 +98696,25 @@ SQLITE_PRIVATE void sqlite3Pragma(

       for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
         Table *pTab = sqliteHashData(x);
         Index *pIdx;
         sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
         cnt++;
         if( HasRowid(pTab) ){
           sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
           VdbeComment((v, "%s", pTab->zName));
           cnt++;
         }
         for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
           sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt);
           VdbeComment((v, "%s", pIdx->zName));
           cnt++;
         }
       }
       /* Make sure sufficient number of registers have been allocated */
       pParse->nMem = MAX( pParse->nMem, cnt+7 );
       pParse->nMem = MAX( pParse->nMem, cnt+8 );
       /* Do the b-tree integrity checks */
       sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1);
       sqlite3VdbeChangeP5(v, (u8)i);
       addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2);
       addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); VdbeCoverage(v);
       sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
          sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
          P4_DYNAMIC);

@@ -96999,58 +98727,65 @@ SQLITE_PRIVATE void sqlite3Pragma(

       */
       for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
         Table *pTab = sqliteHashData(x);
         Index *pIdx;
         Index *pIdx, *pPk;
         Index *pPrior = 0;
         int loopTop;
         int iDataCur, iIdxCur;
         int r1 = -1;
         if( pTab->pIndex==0 ) continue;
         pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
         addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);  /* Stop if out of errors */
         VdbeCoverage(v);
         sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
         sqlite3VdbeJumpHere(v, addr);
         sqlite3ExprCacheClear(pParse);
         sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
         sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead,
 , 0, &iDataCur, &iIdxCur);
         sqlite3VdbeAddOp2(v, OP_Integer, 0, 7);
         for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
           sqlite3VdbeAddOp2(v, OP_Integer, 0, 7+j); /* index entries counter */
           sqlite3VdbeAddOp2(v, OP_Integer, 0, 8+j); /* index entries counter */
         }
         pParse->nMem = MAX(pParse->nMem, 7+j);
         loopTop = sqlite3VdbeAddOp2(v, OP_Rewind, 1, 0) + 1;
         pParse->nMem = MAX(pParse->nMem, 8+j);
         sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v);
         loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1);
         for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
           int jmp2, jmp3;
           int r1;
           static const VdbeOpList idxErr[] = {
             { OP_AddImm,      1, -1,  0},
             { OP_String8,     0,  3,  0},    /* 1 */
             { OP_Rowid,       1,  4,  0},
             { OP_String8,     0,  5,  0},    /* 3 */
             { OP_String8,     0,  6,  0},    /* 4 */
             { OP_Concat,      4,  3,  3},
             { OP_Concat,      5,  3,  3},
             { OP_Concat,      6,  3,  3},
             { OP_ResultRow,   3,  1,  0},
             { OP_IfPos,       1,  0,  0},    /* 9 */
             { OP_Halt,        0,  0,  0},
           };
           r1 = sqlite3GenerateIndexKey(pParse, pIdx, 1, 3, 0, &jmp3);
           sqlite3VdbeAddOp2(v, OP_AddImm, 7+j, 1);  /* increment entry count */
           jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, j+2, 0, r1, pIdx->nColumn+1);
           addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
           sqlite3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC);
           sqlite3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC);
           sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_TRANSIENT);
           sqlite3VdbeJumpHere(v, addr+9);
           int jmp2, jmp3, jmp4;
           if( pPk==pIdx ) continue;
           r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
                                        pPrior, r1);
           pPrior = pIdx;
           sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1);  /* increment entry count */
           jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, 0, r1,
                                       pIdx->nColumn); VdbeCoverage(v);
           sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); /* Decrement error limit */
           sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, "row ", P4_STATIC);
           sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
           sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0, " missing from index ",
                             P4_STATIC);
           sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
           sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0, pIdx->zName, P4_TRANSIENT);
           sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
           sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
           jmp4 = sqlite3VdbeAddOp1(v, OP_IfPos, 1); VdbeCoverage(v);
           sqlite3VdbeAddOp0(v, OP_Halt);
           sqlite3VdbeJumpHere(v, jmp4);
           sqlite3VdbeJumpHere(v, jmp2);
           sqlite3VdbeResolveLabel(v, jmp3);
         }
         sqlite3VdbeAddOp2(v, OP_Next, 1, loopTop);
         sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v);
         sqlite3VdbeJumpHere(v, loopTop-1);
 #ifndef SQLITE_OMIT_BTREECOUNT
         sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0,
                      "wrong # of entries in index ", P4_STATIC);
         for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
           if( pPk==pIdx ) continue;
           addr = sqlite3VdbeCurrentAddr(v);
           sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr+2);
           sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr+2); VdbeCoverage(v);
           sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
           sqlite3VdbeAddOp2(v, OP_Count, j+2, 3);
           sqlite3VdbeAddOp3(v, OP_Eq, 7+j, addr+8, 3);
           sqlite3VdbeAddOp2(v, OP_Count, iIdxCur+j, 3);
           sqlite3VdbeAddOp3(v, OP_Eq, 8+j, addr+8, 3); VdbeCoverage(v);
           sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
           sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
           sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pIdx->zName, P4_TRANSIENT);
           sqlite3VdbeAddOp3(v, OP_Concat, 3, 2, 7);

@@ -97059,7 +98794,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

 #endif /* SQLITE_OMIT_BTREECOUNT */
       }
     }
     addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
     addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
     sqlite3VdbeChangeP2(v, addr, -mxErr);
     sqlite3VdbeJumpHere(v, addr+1);
     sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC);

@@ -97197,7 +98932,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

         { OP_Integer,        0,  1,  0},    /* 1 */
         { OP_SetCookie,      0,  0,  1},    /* 2 */
       };
       int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
       int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0);
       sqlite3VdbeChangeP1(v, addr, iDb);
       sqlite3VdbeChangeP1(v, addr+1, sqlite3Atoi(zRight));
       sqlite3VdbeChangeP1(v, addr+2, iDb);

@@ -97209,7 +98944,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

         { OP_ReadCookie,      0,  1,  0},    /* 1 */
         { OP_ResultRow,       1,  1,  0}
       };
       int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
       int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie, 0);
       sqlite3VdbeChangeP1(v, addr, iDb);
       sqlite3VdbeChangeP1(v, addr+1, iDb);
       sqlite3VdbeChangeP3(v, addr+1, iCookie);

@@ -97945,6 +99680,17 @@ SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){

 }
 /*
 ** Free all memory allocations in the pParse object
 */
 SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){
   if( pParse ){
     sqlite3 *db = pParse->db;
     sqlite3DbFree(db, pParse->aLabel);
     sqlite3ExprListDelete(db, pParse->pConstExpr);
   }
 }
 /*
 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
 */
 static int sqlite3Prepare(

@@ -98101,6 +99847,7 @@ static int sqlite3Prepare(

 end_prepare:
   sqlite3ParserReset(pParse);
   sqlite3StackFree(db, pParse);
   rc = sqlite3ApiExit(db, rc);
   assert( (rc&db->errMask)==rc );

@@ -98324,6 +100071,7 @@ static void clearSelect(sqlite3 *db, Select *p){

   sqlite3SelectDelete(db, p->pPrior);
   sqlite3ExprDelete(db, p->pLimit);
   sqlite3ExprDelete(db, p->pOffset);
   sqlite3WithDelete(db, p->pWith);
 }
 /*

@@ -98404,6 +100152,14 @@ SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3 *db, Select *p){

 }
 /*
 ** Return a pointer to the right-most SELECT statement in a compound.
 */
 static Select *findRightmost(Select *p){
   while( p->pNext ) p = p->pNext;
   return p;
 }
 /*
 ** Given 1 to 3 identifiers preceding the JOIN keyword, determine the
 ** type of join.  Return an integer constant that expresses that type
 ** in terms of the following bit values:

@@ -98741,7 +100497,7 @@ static void pushOntoSorter(

     }else{
       iLimit = pSelect->iLimit;
     }
     addr1 = sqlite3VdbeAddOp1(v, OP_IfZero, iLimit);
     addr1 = sqlite3VdbeAddOp1(v, OP_IfZero, iLimit); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_AddImm, iLimit, -1);
     addr2 = sqlite3VdbeAddOp0(v, OP_Goto);
     sqlite3VdbeJumpHere(v, addr1);

@@ -98756,13 +100512,13 @@ static void pushOntoSorter(

 */
 static void codeOffset(
   Vdbe *v,          /* Generate code into this VM */
   Select *p,        /* The SELECT statement being coded */
   int iOffset,      /* Register holding the offset counter */
   int iContinue     /* Jump here to skip the current record */
 ){
   if( p->iOffset && iContinue!=0 ){
   if( iOffset>0 && iContinue!=0 ){
     int addr;
     sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
     addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
     sqlite3VdbeAddOp2(v, OP_AddImm, iOffset, -1);
     addr = sqlite3VdbeAddOp1(v, OP_IfNeg, iOffset); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Goto, 0, iContinue);
     VdbeComment((v, "skip OFFSET records"));
     sqlite3VdbeJumpHere(v, addr);

@@ -98790,7 +100546,7 @@ static void codeDistinct(

   v = pParse->pVdbe;
   r1 = sqlite3GetTempReg(pParse);
   sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N);
   sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v);
   sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
   sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1);
   sqlite3ReleaseTempReg(pParse, r1);

@@ -98837,17 +100593,16 @@ struct DistinctCtx {

 ** This routine generates the code for the inside of the inner loop
 ** of a SELECT.
 **
 ** If srcTab and nColumn are both zero, then the pEList expressions
 ** are evaluated in order to get the data for this row.  If nColumn>0
 ** then data is pulled from srcTab and pEList is used only to get the
 ** datatypes for each column.
 ** If srcTab is negative, then the pEList expressions
 ** are evaluated in order to get the data for this row.  If srcTab is
 ** zero or more, then data is pulled from srcTab and pEList is used only
 ** to get number columns and the datatype for each column.
 */
 static void selectInnerLoop(
   Parse *pParse,          /* The parser context */
   Select *p,              /* The complete select statement being coded */
   ExprList *pEList,       /* List of values being extracted */
   int srcTab,             /* Pull data from this table */
   int nColumn,            /* Number of columns in the source table */
   ExprList *pOrderBy,     /* If not NULL, sort results using this key */
   DistinctCtx *pDistinct, /* If not NULL, info on how to process DISTINCT */
   SelectDest *pDest,      /* How to dispose of the results */

@@ -98863,48 +100618,47 @@ static void selectInnerLoop(

   int nResultCol;             /* Number of result columns */
   assert( v );
   if( NEVER(v==0) ) return;
   assert( pEList!=0 );
   hasDistinct = pDistinct ? pDistinct->eTnctType : WHERE_DISTINCT_NOOP;
   if( pOrderBy==0 && !hasDistinct ){
     codeOffset(v, p, iContinue);
     codeOffset(v, p->iOffset, iContinue);
   }
   /* Pull the requested columns.
   */
   if( nColumn>0 ){
     nResultCol = nColumn;
   }else{
     nResultCol = pEList->nExpr;
   }
   nResultCol = pEList->nExpr;
   if( pDest->iSdst==0 ){
     pDest->iSdst = pParse->nMem+1;
     pDest->nSdst = nResultCol;
     pParse->nMem += nResultCol;
   }else{
     assert( pDest->nSdst==nResultCol );
   }else if( pDest->iSdst+nResultCol > pParse->nMem ){
     /* This is an error condition that can result, for example, when a SELECT
     ** on the right-hand side of an INSERT contains more result columns than
     ** there are columns in the table on the left.  The error will be caught
     ** and reported later.  But we need to make sure enough memory is allocated
     ** to avoid other spurious errors in the meantime. */
     pParse->nMem += nResultCol;
   }
   pDest->nSdst = nResultCol;
   regResult = pDest->iSdst;
   if( nColumn>0 ){
     for(i=0; i<nColumn; i++){
   if( srcTab>=0 ){
     for(i=0; i<nResultCol; i++){
       sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
       VdbeComment((v, "%s", pEList->a[i].zName));
     }
   }else if( eDest!=SRT_Exists ){
     /* If the destination is an EXISTS(...) expression, the actual
     ** values returned by the SELECT are not required.
     */
     sqlite3ExprCacheClear(pParse);
     sqlite3ExprCodeExprList(pParse, pEList, regResult, eDest==SRT_Output);
     sqlite3ExprCodeExprList(pParse, pEList, regResult,
                   (eDest==SRT_Output||eDest==SRT_Coroutine)?SQLITE_ECEL_DUP:0);
   }
   nColumn = nResultCol;
   /* If the DISTINCT keyword was present on the SELECT statement
   ** and this row has been seen before, then do not make this row
   ** part of the result.
   */
   if( hasDistinct ){
     assert( pEList!=0 );
     assert( pEList->nExpr==nColumn );
     switch( pDistinct->eTnctType ){
       case WHERE_DISTINCT_ORDERED: {
         VdbeOp *pOp;            /* No longer required OpenEphemeral instr. */

@@ -98913,7 +100667,7 @@ static void selectInnerLoop(

         /* Allocate space for the previous row */
         regPrev = pParse->nMem+1;
         pParse->nMem += nColumn;
         pParse->nMem += nResultCol;
         /* Change the OP_OpenEphemeral coded earlier to an OP_Null
         ** sets the MEM_Cleared bit on the first register of the

@@ -98927,19 +100681,21 @@ static void selectInnerLoop(

         pOp->p1 = 1;
         pOp->p2 = regPrev;
         iJump = sqlite3VdbeCurrentAddr(v) + nColumn;
         for(i=0; i<nColumn; i++){
         iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;
         for(i=0; i<nResultCol; i++){
           CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
           if( i<nColumn-1 ){
           if( i<nResultCol-1 ){
             sqlite3VdbeAddOp3(v, OP_Ne, regResult+i, iJump, regPrev+i);
             VdbeCoverage(v);
           }else{
             sqlite3VdbeAddOp3(v, OP_Eq, regResult+i, iContinue, regPrev+i);
           }
             VdbeCoverage(v);
            }
           sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
           sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
         }
         assert( sqlite3VdbeCurrentAddr(v)==iJump );
         sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nColumn-1);
         sqlite3VdbeAddOp3(v, OP_Copy, regResult, regPrev, nResultCol-1);
         break;
       }

@@ -98950,12 +100706,12 @@ static void selectInnerLoop(

       default: {
         assert( pDistinct->eTnctType==WHERE_DISTINCT_UNORDERED );
         codeDistinct(pParse, pDistinct->tabTnct, iContinue, nColumn, regResult);
         codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol, regResult);
         break;
       }
     }
     if( pOrderBy==0 ){
       codeOffset(v, p, iContinue);
       codeOffset(v, p->iOffset, iContinue);
     }
   }

@@ -98967,7 +100723,7 @@ static void selectInnerLoop(

     case SRT_Union: {
       int r1;
       r1 = sqlite3GetTempReg(pParse);
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);
       sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
       sqlite3ReleaseTempReg(pParse, r1);
       break;

@@ -98978,19 +100734,33 @@ static void selectInnerLoop(

     ** the temporary table iParm.
     */
     case SRT_Except: {
       sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nColumn);
       sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol);
       break;
     }
 #endif
 #endif /* SQLITE_OMIT_COMPOUND_SELECT */
     /* Store the result as data using a unique key.
     */
     case SRT_DistTable:
     case SRT_Table:
     case SRT_EphemTab: {
       int r1 = sqlite3GetTempReg(pParse);
       testcase( eDest==SRT_Table );
       testcase( eDest==SRT_EphemTab );
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);
 #ifndef SQLITE_OMIT_CTE
       if( eDest==SRT_DistTable ){
         /* If the destination is DistTable, then cursor (iParm+1) is open
         ** on an ephemeral index. If the current row is already present
         ** in the index, do not write it to the output. If not, add the
         ** current row to the index and proceed with writing it to the
         ** output table as well.  */
         int addr = sqlite3VdbeCurrentAddr(v) + 4;
         sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0); VdbeCoverage(v);
         sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r1);
         assert( pOrderBy==0 );
       }
 #endif
       if( pOrderBy ){
         pushOntoSorter(pParse, pOrderBy, p, r1);
       }else{

@@ -99010,7 +100780,7 @@ static void selectInnerLoop(

     ** item into the set table with bogus data.
     */
     case SRT_Set: {
       assert( nColumn==1 );
       assert( nResultCol==1 );
       pDest->affSdst =
                   sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affSdst);
       if( pOrderBy ){

@@ -99042,7 +100812,7 @@ static void selectInnerLoop(

     ** of the scan loop.
     */
     case SRT_Mem: {
       assert( nColumn==1 );
       assert( nResultCol==1 );
       if( pOrderBy ){
         pushOntoSorter(pParse, pOrderBy, p, regResult);
       }else{

@@ -99053,28 +100823,73 @@ static void selectInnerLoop(

     }
 #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
     /* Send the data to the callback function or to a subroutine.  In the
     ** case of a subroutine, the subroutine itself is responsible for
     ** popping the data from the stack.
     */
     case SRT_Coroutine:
     case SRT_Output: {
     case SRT_Coroutine:       /* Send data to a co-routine */
     case SRT_Output: {        /* Return the results */
       testcase( eDest==SRT_Coroutine );
       testcase( eDest==SRT_Output );
       if( pOrderBy ){
         int r1 = sqlite3GetTempReg(pParse);
         sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
         sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);
         pushOntoSorter(pParse, pOrderBy, p, r1);
         sqlite3ReleaseTempReg(pParse, r1);
       }else if( eDest==SRT_Coroutine ){
         sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
       }else{
         sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nColumn);
         sqlite3ExprCacheAffinityChange(pParse, regResult, nColumn);
         sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol);
         sqlite3ExprCacheAffinityChange(pParse, regResult, nResultCol);
       }
       break;
     }
 #ifndef SQLITE_OMIT_CTE
     /* Write the results into a priority queue that is order according to
     ** pDest->pOrderBy (in pSO).  pDest->iSDParm (in iParm) is the cursor for an
     ** index with pSO->nExpr+2 columns.  Build a key using pSO for the first
     ** pSO->nExpr columns, then make sure all keys are unique by adding a
     ** final OP_Sequence column.  The last column is the record as a blob.
     */
     case SRT_DistQueue:
     case SRT_Queue: {
       int nKey;
       int r1, r2, r3;
       int addrTest = 0;
       ExprList *pSO;
       pSO = pDest->pOrderBy;
       assert( pSO );
       nKey = pSO->nExpr;
       r1 = sqlite3GetTempReg(pParse);
       r2 = sqlite3GetTempRange(pParse, nKey+2);
       r3 = r2+nKey+1;
       if( eDest==SRT_DistQueue ){
         /* If the destination is DistQueue, then cursor (iParm+1) is open
         ** on a second ephemeral index that holds all values every previously
         ** added to the queue. */
         addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0,
                                         regResult, nResultCol);
         VdbeCoverage(v);
       }
       sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3);
       if( eDest==SRT_DistQueue ){
         sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3);
         sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
       }
       for(i=0; i<nKey; i++){
         sqlite3VdbeAddOp2(v, OP_SCopy,
                           regResult + pSO->a[i].u.x.iOrderByCol - 1,
                           r2+i);
       }
       sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey);
       sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1);
       sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
       if( addrTest ) sqlite3VdbeJumpHere(v, addrTest);
       sqlite3ReleaseTempReg(pParse, r1);
       sqlite3ReleaseTempRange(pParse, r2, nKey+2);
       break;
     }
 #endif /* SQLITE_OMIT_CTE */
 #if !defined(SQLITE_OMIT_TRIGGER)
     /* Discard the results.  This is used for SELECT statements inside
     ** the body of a TRIGGER.  The purpose of such selects is to call

@@ -99093,29 +100908,62 @@ static void selectInnerLoop(

   ** the output for us.
   */
   if( pOrderBy==0 && p->iLimit ){
     sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1);
     sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1); VdbeCoverage(v);
   }
 }
 /*
 ** Allocate a KeyInfo object sufficient for an index of N columns.
 **
 ** Actually, always allocate one extra column for the rowid at the end
 ** of the index.  So the KeyInfo returned will have space sufficient for
 ** N+1 columns.
 ** Allocate a KeyInfo object sufficient for an index of N key columns and
 ** X extra columns.
 */
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N){
   KeyInfo *p = sqlite3DbMallocZero(db,
                    sizeof(KeyInfo) + (N+1)*(sizeof(CollSeq*)+1));
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
   KeyInfo *p = sqlite3DbMallocZero(0,
                    sizeof(KeyInfo) + (N+X)*(sizeof(CollSeq*)+1));
   if( p ){
     p->aSortOrder = (u8*)&p->aColl[N+1];
     p->aSortOrder = (u8*)&p->aColl[N+X];
     p->nField = (u16)N;
     p->nXField = (u16)X;
     p->enc = ENC(db);
     p->db = db;
     p->nRef = 1;
   }else{
     db->mallocFailed = 1;
   }
   return p;
 }
 /*
 ** Deallocate a KeyInfo object
 */
 SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo *p){
   if( p ){
     assert( p->nRef>0 );
     p->nRef--;
     if( p->nRef==0 ) sqlite3DbFree(0, p);
   }
 }
 /*
 ** Make a new pointer to a KeyInfo object
 */
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo *p){
   if( p ){
     assert( p->nRef>0 );
     p->nRef++;
   }
   return p;
 }
 #ifdef SQLITE_DEBUG
 /*
 ** Return TRUE if a KeyInfo object can be change.  The KeyInfo object
 ** can only be changed if this is just a single reference to the object.
 **
 ** This routine is used only inside of assert() statements.
 */
 SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; }
 #endif /* SQLITE_DEBUG */
 /*
 ** Given an expression list, generate a KeyInfo structure that records
 ** the collating sequence for each expression in that expression list.

@@ -99128,10 +100976,9 @@ SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N){

 **
 ** Space to hold the KeyInfo structure is obtain from malloc.  The calling
 ** function is responsible for seeing that this structure is eventually
 ** freed.  Add the KeyInfo structure to the P4 field of an opcode using
 ** P4_KEYINFO_HANDOFF is the usual way of dealing with this.
 ** freed.
 */
 static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
 static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList, int nExtra){
   int nExpr;
   KeyInfo *pInfo;
   struct ExprList_item *pItem;

@@ -99139,8 +100986,9 @@ static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){

   int i;
   nExpr = pList->nExpr;
   pInfo = sqlite3KeyInfoAlloc(db, nExpr);
   pInfo = sqlite3KeyInfoAlloc(db, nExpr+nExtra, 1);
   if( pInfo ){
     assert( sqlite3KeyInfoIsWriteable(pInfo) );
     for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
       CollSeq *pColl;
       pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);

@@ -99279,13 +101127,14 @@ static void generateSortTail(

     int ptab2 = pParse->nTab++;
     sqlite3VdbeAddOp3(v, OP_OpenPseudo, ptab2, regSortOut, pOrderBy->nExpr+2);
     addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
     codeOffset(v, p, addrContinue);
     VdbeCoverage(v);
     codeOffset(v, p->iOffset, addrContinue);
     sqlite3VdbeAddOp2(v, OP_SorterData, iTab, regSortOut);
     sqlite3VdbeAddOp3(v, OP_Column, ptab2, pOrderBy->nExpr+1, regRow);
     sqlite3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
   }else{
     addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak);
     codeOffset(v, p, addrContinue);
     addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v);
     codeOffset(v, p->iOffset, addrContinue);
     sqlite3VdbeAddOp3(v, OP_Column, iTab, pOrderBy->nExpr+1, regRow);
   }
   switch( eDest ){

@@ -99342,9 +101191,9 @@ static void generateSortTail(

   */
   sqlite3VdbeResolveLabel(v, addrContinue);
   if( p->selFlags & SF_UseSorter ){
     sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr);
     sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v);
   }else{
     sqlite3VdbeAddOp2(v, OP_Next, iTab, addr);
     sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v);
   }
   sqlite3VdbeResolveLabel(v, addrBreak);
   if( eDest==SRT_Output || eDest==SRT_Coroutine ){

@@ -99464,7 +101313,7 @@ static const char *columnTypeImpl(

           sNC.pParse = pNC->pParse;
           zType = columnType(&sNC, p,&zOrigDb,&zOrigTab,&zOrigCol, &estWidth);
         }
       }else if( ALWAYS(pTab->pSchema) ){
       }else if( pTab->pSchema ){
         /* A real table */
         assert( !pS );
         if( iCol<0 ) iCol = pTab->iPKey;

@@ -99625,8 +101474,9 @@ static void generateColumnNames(

         sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT);
       }
     }else{
       sqlite3VdbeSetColName(v, i, COLNAME_NAME,
           sqlite3DbStrDup(db, pEList->a[i].zSpan), SQLITE_DYNAMIC);
       const char *z = pEList->a[i].zSpan;
       z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z);
       sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC);
     }
   }
   generateColumnTypes(pParse, pTabList, pEList);

@@ -99714,7 +101564,7 @@ static int selectColumnsFromExprList(

         char *zNewName;
         int k;
         for(k=nName-1; k>1 && sqlite3Isdigit(zName[k]); k--){}
         if( zName[k]==':' ) nName = k;
         if( k>=0 && zName[k]==':' ) nName = k;
         zName[nName] = 0;
         zNewName = sqlite3MPrintf(db, "%s:%d", zName, ++cnt);
         sqlite3DbFree(db, zName);

@@ -99826,12 +101676,14 @@ SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect){

 SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){
   Vdbe *v = pParse->pVdbe;
   if( v==0 ){
     v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db);
 #ifndef SQLITE_OMIT_TRACE
     if( v ){
       sqlite3VdbeAddOp0(v, OP_Trace);
     v = pParse->pVdbe = sqlite3VdbeCreate(pParse);
     if( v ) sqlite3VdbeAddOp0(v, OP_Init);
     if( pParse->pToplevel==0
      && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
     ){
       pParse->okConstFactor = 1;
     }
 #endif
   }
   return v;
 }

@@ -99848,8 +101700,13 @@ SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){

 **
 ** This routine changes the values of iLimit and iOffset only if
 ** a limit or offset is defined by pLimit and pOffset.  iLimit and
 ** iOffset should have been preset to appropriate default values
 ** (usually but not always -1) prior to calling this routine.
 ** iOffset should have been preset to appropriate default values (zero)
 ** prior to calling this routine.
 **
 ** The iOffset register (if it exists) is initialized to the value
 ** of the OFFSET.  The iLimit register is initialized to LIMIT.  Register
 ** iOffset+1 is initialized to LIMIT+OFFSET.
 **
 ** Only if pLimit!=0 or pOffset!=0 do the limit registers get
 ** redefined.  The UNION ALL operator uses this property to force
 ** the reuse of the same limit and offset registers across multiple

@@ -99873,7 +101730,7 @@ static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){

   if( p->pLimit ){
     p->iLimit = iLimit = ++pParse->nMem;
     v = sqlite3GetVdbe(pParse);
     if( NEVER(v==0) ) return;  /* VDBE should have already been allocated */
     assert( v!=0 );
     if( sqlite3ExprIsInteger(p->pLimit, &n) ){
       sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
       VdbeComment((v, "LIMIT counter"));

@@ -99884,22 +101741,22 @@ static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){

       }
     }else{
       sqlite3ExprCode(pParse, p->pLimit, iLimit);
       sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit);
       sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
       VdbeComment((v, "LIMIT counter"));
       sqlite3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak);
       sqlite3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak); VdbeCoverage(v);
     }
     if( p->pOffset ){
       p->iOffset = iOffset = ++pParse->nMem;
       pParse->nMem++;   /* Allocate an extra register for limit+offset */
       sqlite3ExprCode(pParse, p->pOffset, iOffset);
       sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset);
       sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v);
       VdbeComment((v, "OFFSET counter"));
       addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset);
       addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset); VdbeCoverage(v);
       sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset);
       sqlite3VdbeJumpHere(v, addr1);
       sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
       VdbeComment((v, "LIMIT+OFFSET"));
       addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iLimit);
       addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iLimit); VdbeCoverage(v);
       sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
       sqlite3VdbeJumpHere(v, addr1);
     }

@@ -99928,9 +101785,209 @@ static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){

   }
   return pRet;
 }
 #endif /* SQLITE_OMIT_COMPOUND_SELECT */
 /* Forward reference */
 /*
 ** The select statement passed as the second parameter is a compound SELECT
 ** with an ORDER BY clause. This function allocates and returns a KeyInfo
 ** structure suitable for implementing the ORDER BY.
 **
 ** Space to hold the KeyInfo structure is obtained from malloc. The calling
 ** function is responsible for ensuring that this structure is eventually
 ** freed.
 */
 static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){
   ExprList *pOrderBy = p->pOrderBy;
   int nOrderBy = p->pOrderBy->nExpr;
   sqlite3 *db = pParse->db;
   KeyInfo *pRet = sqlite3KeyInfoAlloc(db, nOrderBy+nExtra, 1);
   if( pRet ){
     int i;
     for(i=0; i<nOrderBy; i++){
       struct ExprList_item *pItem = &pOrderBy->a[i];
       Expr *pTerm = pItem->pExpr;
       CollSeq *pColl;
       if( pTerm->flags & EP_Collate ){
         pColl = sqlite3ExprCollSeq(pParse, pTerm);
       }else{
         pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
         if( pColl==0 ) pColl = db->pDfltColl;
         pOrderBy->a[i].pExpr =
           sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
       }
       assert( sqlite3KeyInfoIsWriteable(pRet) );
       pRet->aColl[i] = pColl;
       pRet->aSortOrder[i] = pOrderBy->a[i].sortOrder;
     }
   }
   return pRet;
 }
 #ifndef SQLITE_OMIT_CTE
 /*
 ** This routine generates VDBE code to compute the content of a WITH RECURSIVE
 ** query of the form:
 **
 **   <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>)
 **                         \___________/             \_______________/
 **                           p->pPrior                      p
 **
 **
 ** There is exactly one reference to the recursive-table in the FROM clause
 ** of recursive-query, marked with the SrcList->a[].isRecursive flag.
 **
 ** The setup-query runs once to generate an initial set of rows that go
 ** into a Queue table.  Rows are extracted from the Queue table one by
 ** one.  Each row extracted from Queue is output to pDest.  Then the single
 ** extracted row (now in the iCurrent table) becomes the content of the
 ** recursive-table for a recursive-query run.  The output of the recursive-query
 ** is added back into the Queue table.  Then another row is extracted from Queue
 ** and the iteration continues until the Queue table is empty.
 **
 ** If the compound query operator is UNION then no duplicate rows are ever
 ** inserted into the Queue table.  The iDistinct table keeps a copy of all rows
 ** that have ever been inserted into Queue and causes duplicates to be
 ** discarded.  If the operator is UNION ALL, then duplicates are allowed.
 **
 ** If the query has an ORDER BY, then entries in the Queue table are kept in
 ** ORDER BY order and the first entry is extracted for each cycle.  Without
 ** an ORDER BY, the Queue table is just a FIFO.
 **
 ** If a LIMIT clause is provided, then the iteration stops after LIMIT rows
 ** have been output to pDest.  A LIMIT of zero means to output no rows and a
 ** negative LIMIT means to output all rows.  If there is also an OFFSET clause
 ** with a positive value, then the first OFFSET outputs are discarded rather
 ** than being sent to pDest.  The LIMIT count does not begin until after OFFSET
 ** rows have been skipped.
 */
 static void generateWithRecursiveQuery(
   Parse *pParse,        /* Parsing context */
   Select *p,            /* The recursive SELECT to be coded */
   SelectDest *pDest     /* What to do with query results */
 ){
   SrcList *pSrc = p->pSrc;      /* The FROM clause of the recursive query */
   int nCol = p->pEList->nExpr;  /* Number of columns in the recursive table */
   Vdbe *v = pParse->pVdbe;      /* The prepared statement under construction */
   Select *pSetup = p->pPrior;   /* The setup query */
   int addrTop;                  /* Top of the loop */
   int addrCont, addrBreak;      /* CONTINUE and BREAK addresses */
   int iCurrent = 0;             /* The Current table */
   int regCurrent;               /* Register holding Current table */
   int iQueue;                   /* The Queue table */
   int iDistinct = 0;            /* To ensure unique results if UNION */
   int eDest = SRT_Table;        /* How to write to Queue */
   SelectDest destQueue;         /* SelectDest targetting the Queue table */
   int i;                        /* Loop counter */
   int rc;                       /* Result code */
   ExprList *pOrderBy;           /* The ORDER BY clause */
   Expr *pLimit, *pOffset;       /* Saved LIMIT and OFFSET */
   int regLimit, regOffset;      /* Registers used by LIMIT and OFFSET */
   /* Obtain authorization to do a recursive query */
   if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return;
   /* Process the LIMIT and OFFSET clauses, if they exist */
   addrBreak = sqlite3VdbeMakeLabel(v);
   computeLimitRegisters(pParse, p, addrBreak);
   pLimit = p->pLimit;
   pOffset = p->pOffset;
   regLimit = p->iLimit;
   regOffset = p->iOffset;
   p->pLimit = p->pOffset = 0;
   p->iLimit = p->iOffset = 0;
   pOrderBy = p->pOrderBy;
   /* Locate the cursor number of the Current table */
   for(i=0; ALWAYS(i<pSrc->nSrc); i++){
     if( pSrc->a[i].isRecursive ){
       iCurrent = pSrc->a[i].iCursor;
       break;
     }
   }
   /* Allocate cursors numbers for Queue and Distinct.  The cursor number for
   ** the Distinct table must be exactly one greater than Queue in order
   ** for the SRT_DistTable and SRT_DistQueue destinations to work. */
   iQueue = pParse->nTab++;
   if( p->op==TK_UNION ){
     eDest = pOrderBy ? SRT_DistQueue : SRT_DistTable;
     iDistinct = pParse->nTab++;
   }else{
     eDest = pOrderBy ? SRT_Queue : SRT_Table;
   }
   sqlite3SelectDestInit(&destQueue, eDest, iQueue);
   /* Allocate cursors for Current, Queue, and Distinct. */
   regCurrent = ++pParse->nMem;
   sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
   if( pOrderBy ){
     KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
     sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0,
                       (char*)pKeyInfo, P4_KEYINFO);
     destQueue.pOrderBy = pOrderBy;
   }else{
     sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
   }
   VdbeComment((v, "Queue table"));
   if( iDistinct ){
     p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
     p->selFlags |= SF_UsesEphemeral;
   }
   /* Detach the ORDER BY clause from the compound SELECT */
   p->pOrderBy = 0;
   /* Store the results of the setup-query in Queue. */
   pSetup->pNext = 0;
   rc = sqlite3Select(pParse, pSetup, &destQueue);
   pSetup->pNext = p;
   if( rc ) goto end_of_recursive_query;
   /* Find the next row in the Queue and output that row */
   addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v);
   /* Transfer the next row in Queue over to Current */
   sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */
   if( pOrderBy ){
     sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent);
   }else{
     sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent);
   }
   sqlite3VdbeAddOp1(v, OP_Delete, iQueue);
   /* Output the single row in Current */
   addrCont = sqlite3VdbeMakeLabel(v);
   codeOffset(v, regOffset, addrCont);
   selectInnerLoop(pParse, p, p->pEList, iCurrent,
 , 0, pDest, addrCont, addrBreak);
   if( regLimit ){
     sqlite3VdbeAddOp3(v, OP_IfZero, regLimit, addrBreak, -1);
     VdbeCoverage(v);
   }
   sqlite3VdbeResolveLabel(v, addrCont);
   /* Execute the recursive SELECT taking the single row in Current as
   ** the value for the recursive-table. Store the results in the Queue.
   */
   p->pPrior = 0;
   sqlite3Select(pParse, p, &destQueue);
   assert( p->pPrior==0 );
   p->pPrior = pSetup;
   /* Keep running the loop until the Queue is empty */
   sqlite3VdbeAddOp2(v, OP_Goto, 0, addrTop);
   sqlite3VdbeResolveLabel(v, addrBreak);
 end_of_recursive_query:
   p->pOrderBy = pOrderBy;
   p->pLimit = pLimit;
   p->pOffset = pOffset;
   return;
 }
 #endif /* SQLITE_OMIT_CTE */
 /* Forward references */
 static int multiSelectOrderBy(
   Parse *pParse,        /* Parsing context */
   Select *p,            /* The right-most of SELECTs to be coded */

@@ -99938,7 +101995,6 @@ static int multiSelectOrderBy(

 );
 #ifndef SQLITE_OMIT_COMPOUND_SELECT
 /*
 ** This routine is called to process a compound query form from
 ** two or more separate queries using UNION, UNION ALL, EXCEPT, or

@@ -99982,18 +102038,17 @@ static int multiSelect(

   Select *pDelete = 0;  /* Chain of simple selects to delete */
   sqlite3 *db;          /* Database connection */
 #ifndef SQLITE_OMIT_EXPLAIN
   int iSub1;            /* EQP id of left-hand query */
   int iSub2;            /* EQP id of right-hand query */
   int iSub1 = 0;        /* EQP id of left-hand query */
   int iSub2 = 0;        /* EQP id of right-hand query */
 #endif
   /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs.  Only
   ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
   */
   assert( p && p->pPrior );  /* Calling function guarantees this much */
   assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
   db = pParse->db;
   pPrior = p->pPrior;
   assert( pPrior->pRightmost!=pPrior );
   assert( pPrior->pRightmost==p->pRightmost );
   dest = *pDest;
   if( pPrior->pOrderBy ){
     sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",

@@ -100035,11 +102090,17 @@ static int multiSelect(

     goto multi_select_end;
   }
 #ifndef SQLITE_OMIT_CTE
   if( p->selFlags & SF_Recursive ){
     generateWithRecursiveQuery(pParse, p, &dest);
   }else
 #endif
   /* Compound SELECTs that have an ORDER BY clause are handled separately.
   */
   if( p->pOrderBy ){
     return multiSelectOrderBy(pParse, p, pDest);
   }
   }else
   /* Generate code for the left and right SELECT statements.
   */

@@ -100063,7 +102124,7 @@ static int multiSelect(

       p->iLimit = pPrior->iLimit;
       p->iOffset = pPrior->iOffset;
       if( p->iLimit ){
         addr = sqlite3VdbeAddOp1(v, OP_IfZero, p->iLimit);
         addr = sqlite3VdbeAddOp1(v, OP_IfZero, p->iLimit); VdbeCoverage(v);
         VdbeComment((v, "Jump ahead if LIMIT reached"));
       }
       explainSetInteger(iSub2, pParse->iNextSelectId);

@@ -100095,12 +102156,10 @@ static int multiSelect(

       testcase( p->op==TK_EXCEPT );
       testcase( p->op==TK_UNION );
       priorOp = SRT_Union;
       if( dest.eDest==priorOp && ALWAYS(!p->pLimit &&!p->pOffset) ){
       if( dest.eDest==priorOp ){
         /* We can reuse a temporary table generated by a SELECT to our
         ** right.
         */
         assert( p->pRightmost!=p );  /* Can only happen for leftward elements
                                      ** of a 3-way or more compound */
         assert( p->pLimit==0 );      /* Not allowed on leftward elements */
         assert( p->pOffset==0 );     /* Not allowed on leftward elements */
         unionTab = dest.iSDParm;

@@ -100113,7 +102172,7 @@ static int multiSelect(

         addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
         assert( p->addrOpenEphm[0] == -1 );
         p->addrOpenEphm[0] = addr;
         p->pRightmost->selFlags |= SF_UsesEphemeral;
         findRightmost(p)->selFlags |= SF_UsesEphemeral;
         assert( p->pEList );
       }

@@ -100172,12 +102231,12 @@ static int multiSelect(

         iBreak = sqlite3VdbeMakeLabel(v);
         iCont = sqlite3VdbeMakeLabel(v);
         computeLimitRegisters(pParse, p, iBreak);
         sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak);
         sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v);
         iStart = sqlite3VdbeCurrentAddr(v);
         selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
         selectInnerLoop(pParse, p, p->pEList, unionTab,
 , 0, &dest, iCont, iBreak);
         sqlite3VdbeResolveLabel(v, iCont);
         sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart);
         sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v);
         sqlite3VdbeResolveLabel(v, iBreak);
         sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
       }

@@ -100202,7 +102261,7 @@ static int multiSelect(

       addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
       assert( p->addrOpenEphm[0] == -1 );
       p->addrOpenEphm[0] = addr;
       p->pRightmost->selFlags |= SF_UsesEphemeral;
       findRightmost(p)->selFlags |= SF_UsesEphemeral;
       assert( p->pEList );
       /* Code the SELECTs to our left into temporary table "tab1".

@@ -100247,15 +102306,15 @@ static int multiSelect(

       iBreak = sqlite3VdbeMakeLabel(v);
       iCont = sqlite3VdbeMakeLabel(v);
       computeLimitRegisters(pParse, p, iBreak);
       sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak);
       sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v);
       r1 = sqlite3GetTempReg(pParse);
       iStart = sqlite3VdbeAddOp2(v, OP_RowKey, tab1, r1);
       sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
       sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0); VdbeCoverage(v);
       sqlite3ReleaseTempReg(pParse, r1);
       selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
       selectInnerLoop(pParse, p, p->pEList, tab1,
 , 0, &dest, iCont, iBreak);
       sqlite3VdbeResolveLabel(v, iCont);
       sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart);
       sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v);
       sqlite3VdbeResolveLabel(v, iBreak);
       sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
       sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);

@@ -100281,9 +102340,9 @@ static int multiSelect(

     CollSeq **apColl;             /* For looping through pKeyInfo->aColl[] */
     int nCol;                     /* Number of columns in result set */
     assert( p->pRightmost==p );
     assert( p->pNext==0 );
     nCol = p->pEList->nExpr;
     pKeyInfo = sqlite3KeyInfoAlloc(db, nCol);
     pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
     if( !pKeyInfo ){
       rc = SQLITE_NOMEM;
       goto multi_select_end;

@@ -100305,11 +102364,12 @@ static int multiSelect(

           break;
         }
         sqlite3VdbeChangeP2(v, addr, nCol);
         sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO);
         sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
                             P4_KEYINFO);
         pLoop->addrOpenEphm[i] = -1;
       }
     }
     sqlite3DbFree(db, pKeyInfo);
     sqlite3KeyInfoUnref(pKeyInfo);
   }
 multi_select_end:

@@ -100348,7 +102408,6 @@ static int generateOutputSubroutine(

   int regReturn,          /* The return address register */
   int regPrev,            /* Previous result register.  No uniqueness if 0 */
   KeyInfo *pKeyInfo,      /* For comparing with previous entry */
   int p4type,             /* The p4 type for pKeyInfo */
   int iBreak              /* Jump here if we hit the LIMIT */
 ){
   Vdbe *v = pParse->pVdbe;

@@ -100362,10 +102421,10 @@ static int generateOutputSubroutine(

   */
   if( regPrev ){
     int j1, j2;
     j1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev);
     j1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v);
     j2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst,
                               (char*)pKeyInfo, p4type);
     sqlite3VdbeAddOp3(v, OP_Jump, j2+2, iContinue, j2+2);
                               (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
     sqlite3VdbeAddOp3(v, OP_Jump, j2+2, iContinue, j2+2); VdbeCoverage(v);
     sqlite3VdbeJumpHere(v, j1);
     sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1);
     sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);

@@ -100374,7 +102433,7 @@ static int generateOutputSubroutine(

   /* Suppress the first OFFSET entries if there is an OFFSET clause
   */
   codeOffset(v, p, iContinue);
   codeOffset(v, p->iOffset, iContinue);
   switch( pDest->eDest ){
     /* Store the result as data using a unique key.

@@ -100466,7 +102525,7 @@ static int generateOutputSubroutine(

   /* Jump to the end of the loop if the LIMIT is reached.
   */
   if( p->iLimit ){
     sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1);
     sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1); VdbeCoverage(v);
   }
   /* Generate the subroutine return

@@ -100574,9 +102633,7 @@ static int multiSelectOrderBy(

   SelectDest destA;     /* Destination for coroutine A */
   SelectDest destB;     /* Destination for coroutine B */
   int regAddrA;         /* Address register for select-A coroutine */
   int regEofA;          /* Flag to indicate when select-A is complete */
   int regAddrB;         /* Address register for select-B coroutine */
   int regEofB;          /* Flag to indicate when select-B is complete */
   int addrSelectA;      /* Address of the select-A coroutine */
   int addrSelectB;      /* Address of the select-B coroutine */
   int regOutA;          /* Address register for the output-A subroutine */

@@ -100584,6 +102641,7 @@ static int multiSelectOrderBy(

   int addrOutA;         /* Address of the output-A subroutine */
   int addrOutB = 0;     /* Address of the output-B subroutine */
   int addrEofA;         /* Address of the select-A-exhausted subroutine */
   int addrEofA_noB;     /* Alternate addrEofA if B is uninitialized */
   int addrEofB;         /* Address of the select-B-exhausted subroutine */
   int addrAltB;         /* Address of the A<B subroutine */
   int addrAeqB;         /* Address of the A==B subroutine */

@@ -100634,8 +102692,8 @@ static int multiSelectOrderBy(

     for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
       struct ExprList_item *pItem;
       for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
         assert( pItem->iOrderByCol>0 );
         if( pItem->iOrderByCol==i ) break;
         assert( pItem->u.x.iOrderByCol>0 );
         if( pItem->u.x.iOrderByCol==i ) break;
       }
       if( j==nOrderBy ){
         Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);

@@ -100643,7 +102701,7 @@ static int multiSelectOrderBy(

         pNew->flags |= EP_IntValue;
         pNew->u.iValue = i;
         pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
         if( pOrderBy ) pOrderBy->a[nOrderBy++].iOrderByCol = (u16)i;
         if( pOrderBy ) pOrderBy->a[nOrderBy++].u.x.iOrderByCol = (u16)i;
       }
     }
   }

@@ -100659,26 +102717,11 @@ static int multiSelectOrderBy(

   if( aPermute ){
     struct ExprList_item *pItem;
     for(i=0, pItem=pOrderBy->a; i<nOrderBy; i++, pItem++){
       assert( pItem->iOrderByCol>0  && pItem->iOrderByCol<=p->pEList->nExpr );
       aPermute[i] = pItem->iOrderByCol - 1;
     }
     pKeyMerge = sqlite3KeyInfoAlloc(db, nOrderBy);
     if( pKeyMerge ){
       for(i=0; i<nOrderBy; i++){
         CollSeq *pColl;
         Expr *pTerm = pOrderBy->a[i].pExpr;
         if( pTerm->flags & EP_Collate ){
           pColl = sqlite3ExprCollSeq(pParse, pTerm);
         }else{
           pColl = multiSelectCollSeq(pParse, p, aPermute[i]);
           if( pColl==0 ) pColl = db->pDfltColl;
           pOrderBy->a[i].pExpr =
              sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
         }
         pKeyMerge->aColl[i] = pColl;
         pKeyMerge->aSortOrder[i] = pOrderBy->a[i].sortOrder;
       }
       assert( pItem->u.x.iOrderByCol>0
           && pItem->u.x.iOrderByCol<=p->pEList->nExpr );
       aPermute[i] = pItem->u.x.iOrderByCol - 1;
     }
     pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1);
   }else{
     pKeyMerge = 0;
   }

@@ -100700,8 +102743,9 @@ static int multiSelectOrderBy(

     regPrev = pParse->nMem+1;
     pParse->nMem += nExpr+1;
     sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
     pKeyDup = sqlite3KeyInfoAlloc(db, nExpr);
     pKeyDup = sqlite3KeyInfoAlloc(db, nExpr, 1);
     if( pKeyDup ){
       assert( sqlite3KeyInfoIsWriteable(pKeyDup) );
       for(i=0; i<nExpr; i++){
         pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
         pKeyDup->aSortOrder[i] = 0;

@@ -100712,6 +102756,7 @@ static int multiSelectOrderBy(

   /* Separate the left and the right query from one another
   */
   p->pPrior = 0;
   pPrior->pNext = 0;
   sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
   if( pPrior->pPrior==0 ){
     sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");

@@ -100734,37 +102779,30 @@ static int multiSelectOrderBy(

   p->pOffset = 0;
   regAddrA = ++pParse->nMem;
   regEofA = ++pParse->nMem;
   regAddrB = ++pParse->nMem;
   regEofB = ++pParse->nMem;
   regOutA = ++pParse->nMem;
   regOutB = ++pParse->nMem;
   sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
   sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
   /* Jump past the various subroutines and coroutines to the main
   ** merge loop
   */
   j1 = sqlite3VdbeAddOp0(v, OP_Goto);
   addrSelectA = sqlite3VdbeCurrentAddr(v);
   /* Generate a coroutine to evaluate the SELECT statement to the
   ** left of the compound operator - the "A" select.
   */
   VdbeNoopComment((v, "Begin coroutine for left SELECT"));
   addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
   j1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
   VdbeComment((v, "left SELECT"));
   pPrior->iLimit = regLimitA;
   explainSetInteger(iSub1, pParse->iNextSelectId);
   sqlite3Select(pParse, pPrior, &destA);
   sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofA);
   sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
   VdbeNoopComment((v, "End coroutine for left SELECT"));
   sqlite3VdbeAddOp1(v, OP_EndCoroutine, regAddrA);
   sqlite3VdbeJumpHere(v, j1);
   /* Generate a coroutine to evaluate the SELECT statement on
   ** the right - the "B" select
   */
   addrSelectB = sqlite3VdbeCurrentAddr(v);
   VdbeNoopComment((v, "Begin coroutine for right SELECT"));
   addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
   j1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
   VdbeComment((v, "right SELECT"));
   savedLimit = p->iLimit;
   savedOffset = p->iOffset;
   p->iLimit = regLimitB;

@@ -100773,9 +102811,7 @@ static int multiSelectOrderBy(

   sqlite3Select(pParse, p, &destB);
   p->iLimit = savedLimit;
   p->iOffset = savedOffset;
   sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofB);
   sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
   VdbeNoopComment((v, "End coroutine for right SELECT"));
   sqlite3VdbeAddOp1(v, OP_EndCoroutine, regAddrB);
   /* Generate a subroutine that outputs the current row of the A
   ** select as the next output row of the compound select.

@@ -100783,7 +102819,7 @@ static int multiSelectOrderBy(

   VdbeNoopComment((v, "Output routine for A"));
   addrOutA = generateOutputSubroutine(pParse,
                  p, &destA, pDest, regOutA,
                  regPrev, pKeyDup, P4_KEYINFO_HANDOFF, labelEnd);
                  regPrev, pKeyDup, labelEnd);
   /* Generate a subroutine that outputs the current row of the B
   ** select as the next output row of the compound select.

@@ -100792,19 +102828,20 @@ static int multiSelectOrderBy(

     VdbeNoopComment((v, "Output routine for B"));
     addrOutB = generateOutputSubroutine(pParse,
                  p, &destB, pDest, regOutB,
                  regPrev, pKeyDup, P4_KEYINFO_STATIC, labelEnd);
                  regPrev, pKeyDup, labelEnd);
   }
   sqlite3KeyInfoUnref(pKeyDup);
   /* Generate a subroutine to run when the results from select A
   ** are exhausted and only data in select B remains.
   */
   VdbeNoopComment((v, "eof-A subroutine"));
   if( op==TK_EXCEPT || op==TK_INTERSECT ){
     addrEofA = sqlite3VdbeAddOp2(v, OP_Goto, 0, labelEnd);
     addrEofA_noB = addrEofA = labelEnd;
   }else{
     addrEofA = sqlite3VdbeAddOp2(v, OP_If, regEofB, labelEnd);
     sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
     sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
     VdbeNoopComment((v, "eof-A subroutine"));
     addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
     addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd);
                                      VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofA);
     p->nSelectRow += pPrior->nSelectRow;
   }

@@ -100817,9 +102854,8 @@ static int multiSelectOrderBy(

     if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
   }else{
     VdbeNoopComment((v, "eof-B subroutine"));
     addrEofB = sqlite3VdbeAddOp2(v, OP_If, regEofA, labelEnd);
     sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
     sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
     addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
     sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofB);
   }

@@ -100827,8 +102863,7 @@ static int multiSelectOrderBy(

   */
   VdbeNoopComment((v, "A-lt-B subroutine"));
   addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
   sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
   sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
   sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
   sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
   /* Generate code to handle the case of A==B

@@ -100841,8 +102876,7 @@ static int multiSelectOrderBy(

   }else{
     VdbeNoopComment((v, "A-eq-B subroutine"));
     addrAeqB =
     sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
     sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
     sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
   }

@@ -100853,28 +102887,23 @@ static int multiSelectOrderBy(

   if( op==TK_ALL || op==TK_UNION ){
     sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
   }
   sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
   sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
   sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
   sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
   /* This code runs once to initialize everything.
   */
   sqlite3VdbeJumpHere(v, j1);
   sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofA);
   sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofB);
   sqlite3VdbeAddOp2(v, OP_Gosub, regAddrA, addrSelectA);
   sqlite3VdbeAddOp2(v, OP_Gosub, regAddrB, addrSelectB);
   sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
   sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
   sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v);
   sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
   /* Implement the main merge loop
   */
   sqlite3VdbeResolveLabel(v, labelCmpr);
   sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
   sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
                          (char*)pKeyMerge, P4_KEYINFO_HANDOFF);
                          (char*)pKeyMerge, P4_KEYINFO);
   sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
   sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB);
   sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v);
   /* Jump to the this point in order to terminate the query.
   */

@@ -100894,6 +102923,7 @@ static int multiSelectOrderBy(

     sqlite3SelectDelete(db, p->pPrior);
   }
   p->pPrior = pPrior;
   pPrior->pNext = p;
   /*** TBD:  Insert subroutine calls to close cursors on incomplete
   **** subqueries ****/

@@ -101099,6 +103129,14 @@ static void substSelect(

 **  (21)  The subquery does not use LIMIT or the outer query is not
 **        DISTINCT.  (See ticket [752e1646fc]).
 **
 **  (22)  The subquery is not a recursive CTE.
 **
 **  (23)  The parent is not a recursive CTE, or the sub-query is not a
 **        compound query. This restriction is because transforming the
 **        parent to a compound query confuses the code that handles
 **        recursive queries in multiSelect().
 **
 **
 ** In this routine, the "p" parameter is a pointer to the outer query.
 ** The subquery is p->pSrc->a[iFrom].  isAgg is true if the outer query
 ** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.

@@ -101151,7 +103189,7 @@ static int flattenSubquery(

   ** and (14). */
   if( pSub->pLimit && p->pLimit ) return 0;              /* Restriction (13) */
   if( pSub->pOffset ) return 0;                          /* Restriction (14) */
   if( p->pRightmost && pSub->pLimit ){
   if( (p->selFlags & SF_Compound)!=0 && pSub->pLimit ){
     return 0;                                            /* Restriction (15) */
   }
   if( pSubSrc->nSrc==0 ) return 0;                       /* Restriction (7)  */

@@ -101170,6 +103208,8 @@ static int flattenSubquery(

   if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
      return 0;         /* Restriction (21) */
   }
   if( pSub->selFlags & SF_Recursive ) return 0;          /* Restriction (22)  */
   if( (p->selFlags & SF_Recursive) && pSub->pPrior ) return 0;       /* (23)  */
   /* OBSOLETE COMMENT 1:
   ** Restriction 3:  If the subquery is a join, make sure the subquery is

@@ -101237,7 +103277,7 @@ static int flattenSubquery(

     if( p->pOrderBy ){
       int ii;
       for(ii=0; ii<p->pOrderBy->nExpr; ii++){
         if( p->pOrderBy->a[ii].iOrderByCol==0 ) return 0;
         if( p->pOrderBy->a[ii].u.x.iOrderByCol==0 ) return 0;
       }
     }
   }

@@ -101300,14 +103340,14 @@ static int flattenSubquery(

     p->pOrderBy = pOrderBy;
     p->pSrc = pSrc;
     p->op = TK_ALL;
     p->pRightmost = 0;
     if( pNew==0 ){
       pNew = pPrior;
       p->pPrior = pPrior;
     }else{
       pNew->pPrior = pPrior;
       pNew->pRightmost = 0;
       if( pPrior ) pPrior->pNext = pNew;
       pNew->pNext = p;
       p->pPrior = pNew;
     }
     p->pPrior = pNew;
     if( db->mallocFailed ) return 1;
   }

@@ -101646,11 +103686,207 @@ static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){

   pNew->pHaving = 0;
   pNew->pOrderBy = 0;
   p->pPrior = 0;
   p->pNext = 0;
   p->selFlags &= ~SF_Compound;
   assert( pNew->pPrior!=0 );
   pNew->pPrior->pNext = pNew;
   pNew->pLimit = 0;
   pNew->pOffset = 0;
   return WRC_Continue;
 }
 #ifndef SQLITE_OMIT_CTE
 /*
 ** Argument pWith (which may be NULL) points to a linked list of nested
 ** WITH contexts, from inner to outermost. If the table identified by
 ** FROM clause element pItem is really a common-table-expression (CTE)
 ** then return a pointer to the CTE definition for that table. Otherwise
 ** return NULL.
 **
 ** If a non-NULL value is returned, set *ppContext to point to the With
 ** object that the returned CTE belongs to.
 */
 static struct Cte *searchWith(
   With *pWith,                    /* Current outermost WITH clause */
   struct SrcList_item *pItem,     /* FROM clause element to resolve */
   With **ppContext                /* OUT: WITH clause return value belongs to */
 ){
   const char *zName;
   if( pItem->zDatabase==0 && (zName = pItem->zName)!=0 ){
     With *p;
     for(p=pWith; p; p=p->pOuter){
       int i;
       for(i=0; i<p->nCte; i++){
         if( sqlite3StrICmp(zName, p->a[i].zName)==0 ){
           *ppContext = p;
           return &p->a[i];
         }
       }
     }
   }
   return 0;
 }
 /* The code generator maintains a stack of active WITH clauses
 ** with the inner-most WITH clause being at the top of the stack.
 **
 ** This routine pushes the WITH clause passed as the second argument
 ** onto the top of the stack. If argument bFree is true, then this
 ** WITH clause will never be popped from the stack. In this case it
 ** should be freed along with the Parse object. In other cases, when
 ** bFree==0, the With object will be freed along with the SELECT
 ** statement with which it is associated.
 */
 SQLITE_PRIVATE void sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){
   assert( bFree==0 || pParse->pWith==0 );
   if( pWith ){
     pWith->pOuter = pParse->pWith;
     pParse->pWith = pWith;
     pParse->bFreeWith = bFree;
   }
 }
 /*
 ** This function checks if argument pFrom refers to a CTE declared by
 ** a WITH clause on the stack currently maintained by the parser. And,
 ** if currently processing a CTE expression, if it is a recursive
 ** reference to the current CTE.
 **
 ** If pFrom falls into either of the two categories above, pFrom->pTab
 ** and other fields are populated accordingly. The caller should check
 ** (pFrom->pTab!=0) to determine whether or not a successful match
 ** was found.
 **
 ** Whether or not a match is found, SQLITE_OK is returned if no error
 ** occurs. If an error does occur, an error message is stored in the
 ** parser and some error code other than SQLITE_OK returned.
 */
 static int withExpand(
   Walker *pWalker,
   struct SrcList_item *pFrom
 ){
   Parse *pParse = pWalker->pParse;
   sqlite3 *db = pParse->db;
   struct Cte *pCte;               /* Matched CTE (or NULL if no match) */
   With *pWith;                    /* WITH clause that pCte belongs to */
   assert( pFrom->pTab==0 );
   pCte = searchWith(pParse->pWith, pFrom, &pWith);
   if( pCte ){
     Table *pTab;
     ExprList *pEList;
     Select *pSel;
     Select *pLeft;                /* Left-most SELECT statement */
     int bMayRecursive;            /* True if compound joined by UNION [ALL] */
     With *pSavedWith;             /* Initial value of pParse->pWith */
     /* If pCte->zErr is non-NULL at this point, then this is an illegal
     ** recursive reference to CTE pCte. Leave an error in pParse and return
     ** early. If pCte->zErr is NULL, then this is not a recursive reference.
     ** In this case, proceed.  */
     if( pCte->zErr ){
       sqlite3ErrorMsg(pParse, pCte->zErr, pCte->zName);
       return SQLITE_ERROR;
     }
     assert( pFrom->pTab==0 );
     pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
     if( pTab==0 ) return WRC_Abort;
     pTab->nRef = 1;
     pTab->zName = sqlite3DbStrDup(db, pCte->zName);
     pTab->iPKey = -1;
     pTab->nRowEst = 1048576;
     pTab->tabFlags |= TF_Ephemeral;
     pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
     if( db->mallocFailed ) return SQLITE_NOMEM;
     assert( pFrom->pSelect );
     /* Check if this is a recursive CTE. */
     pSel = pFrom->pSelect;
     bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION );
     if( bMayRecursive ){
       int i;
       SrcList *pSrc = pFrom->pSelect->pSrc;
       for(i=0; i<pSrc->nSrc; i++){
         struct SrcList_item *pItem = &pSrc->a[i];
         if( pItem->zDatabase==0
          && pItem->zName!=0
          && 0==sqlite3StrICmp(pItem->zName, pCte->zName)
           ){
           pItem->pTab = pTab;
           pItem->isRecursive = 1;
           pTab->nRef++;
           pSel->selFlags |= SF_Recursive;
         }
       }
     }
     /* Only one recursive reference is permitted. */
     if( pTab->nRef>2 ){
       sqlite3ErrorMsg(
           pParse, "multiple references to recursive table: %s", pCte->zName
       );
       return SQLITE_ERROR;
     }
     assert( pTab->nRef==1 || ((pSel->selFlags&SF_Recursive) && pTab->nRef==2 ));
     pCte->zErr = "circular reference: %s";
     pSavedWith = pParse->pWith;
     pParse->pWith = pWith;
     sqlite3WalkSelect(pWalker, bMayRecursive ? pSel->pPrior : pSel);
     for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
     pEList = pLeft->pEList;
     if( pCte->pCols ){
       if( pEList->nExpr!=pCte->pCols->nExpr ){
         sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns",
             pCte->zName, pEList->nExpr, pCte->pCols->nExpr
         );
         pParse->pWith = pSavedWith;
         return SQLITE_ERROR;
       }
       pEList = pCte->pCols;
     }
     selectColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
     if( bMayRecursive ){
       if( pSel->selFlags & SF_Recursive ){
         pCte->zErr = "multiple recursive references: %s";
       }else{
         pCte->zErr = "recursive reference in a subquery: %s";
       }
       sqlite3WalkSelect(pWalker, pSel);
     }
     pCte->zErr = 0;
     pParse->pWith = pSavedWith;
   }
   return SQLITE_OK;
 }
 #endif
 #ifndef SQLITE_OMIT_CTE
 /*
 ** If the SELECT passed as the second argument has an associated WITH
 ** clause, pop it from the stack stored as part of the Parse object.
 **
 ** This function is used as the xSelectCallback2() callback by
 ** sqlite3SelectExpand() when walking a SELECT tree to resolve table
 ** names and other FROM clause elements.
 */
 static void selectPopWith(Walker *pWalker, Select *p){
   Parse *pParse = pWalker->pParse;
   With *pWith = findRightmost(p)->pWith;
   if( pWith!=0 ){
     assert( pParse->pWith==pWith );
     pParse->pWith = pWith->pOuter;
   }
 }
 #else
 #define selectPopWith 0
 #endif
 /*
 ** This routine is a Walker callback for "expanding" a SELECT statement.
 ** "Expanding" means to do the following:

@@ -101694,6 +103930,7 @@ static int selectExpander(Walker *pWalker, Select *p){

   }
   pTabList = p->pSrc;
   pEList = p->pEList;
   sqlite3WithPush(pParse, findRightmost(p)->pWith, 0);
   /* Make sure cursor numbers have been assigned to all entries in
   ** the FROM clause of the SELECT statement.

@@ -101706,12 +103943,21 @@ static int selectExpander(Walker *pWalker, Select *p){

   */
   for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
     Table *pTab;
     assert( pFrom->isRecursive==0 || pFrom->pTab );
     if( pFrom->isRecursive ) continue;
     if( pFrom->pTab!=0 ){
       /* This statement has already been prepared.  There is no need
       ** to go further. */
       assert( i==0 );
 #ifndef SQLITE_OMIT_CTE
       selectPopWith(pWalker, p);
 #endif
       return WRC_Prune;
     }
 #ifndef SQLITE_OMIT_CTE
     if( withExpand(pWalker, pFrom) ) return WRC_Abort;
     if( pFrom->pTab ) {} else
 #endif
     if( pFrom->zName==0 ){
 #ifndef SQLITE_OMIT_SUBQUERY
       Select *pSel = pFrom->pSelect;

@@ -101974,6 +104220,7 @@ static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){

     sqlite3WalkSelect(&w, pSelect);
   }
   w.xSelectCallback = selectExpander;
   w.xSelectCallback2 = selectPopWith;
   sqlite3WalkSelect(&w, pSelect);
 }

@@ -101992,7 +104239,7 @@ static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){

 ** at that point because identifiers had not yet been resolved.  This
 ** routine is called after identifier resolution.
 */
 static int selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
 static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
   Parse *pParse;
   int i;
   SrcList *pTabList;

@@ -102008,13 +104255,13 @@ static int selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){

       if( ALWAYS(pTab!=0) && (pTab->tabFlags & TF_Ephemeral)!=0 ){
         /* A sub-query in the FROM clause of a SELECT */
         Select *pSel = pFrom->pSelect;
         assert( pSel );
         while( pSel->pPrior ) pSel = pSel->pPrior;
         selectAddColumnTypeAndCollation(pParse, pTab, pSel);
         if( pSel ){
           while( pSel->pPrior ) pSel = pSel->pPrior;
           selectAddColumnTypeAndCollation(pParse, pTab, pSel);
         }
       }
     }
   }
   return WRC_Continue;
 }
 #endif

@@ -102030,10 +104277,9 @@ static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){

 #ifndef SQLITE_OMIT_SUBQUERY
   Walker w;
   memset(&w, 0, sizeof(w));
   w.xSelectCallback = selectAddSubqueryTypeInfo;
   w.xSelectCallback2 = selectAddSubqueryTypeInfo;
   w.xExprCallback = exprWalkNoop;
   w.pParse = pParse;
   w.bSelectDepthFirst = 1;
   sqlite3WalkSelect(&w, pSelect);
 #endif
 }

@@ -102080,14 +104326,23 @@ static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){

   Vdbe *v = pParse->pVdbe;
   int i;
   struct AggInfo_func *pFunc;
   if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){
     return;
   }
   int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
   if( nReg==0 ) return;
 #ifdef SQLITE_DEBUG
   /* Verify that all AggInfo registers are within the range specified by
   ** AggInfo.mnReg..AggInfo.mxReg */
   assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );
   for(i=0; i<pAggInfo->nColumn; i++){
     sqlite3VdbeAddOp2(v, OP_Null, 0, pAggInfo->aCol[i].iMem);
     assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg
          && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg );
   }
   for(i=0; i<pAggInfo->nFunc; i++){
     assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg
          && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg );
   }
 #endif
   sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg);
   for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
     sqlite3VdbeAddOp2(v, OP_Null, 0, pFunc->iMem);
     if( pFunc->iDistinct>=0 ){
       Expr *pE = pFunc->pExpr;
       assert( !ExprHasProperty(pE, EP_xIsSelect) );

@@ -102096,9 +104351,9 @@ static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){

            "argument");
         pFunc->iDistinct = -1;
       }else{
         KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->x.pList);
         KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->x.pList, 0);
         sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
                           (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
                           (char*)pKeyInfo, P4_KEYINFO);
       }
     }
   }

@@ -102133,7 +104388,6 @@ static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){

   struct AggInfo_col *pC;
   pAggInfo->directMode = 1;
   sqlite3ExprCacheClear(pParse);
   for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
     int nArg;
     int addrNext = 0;

@@ -102143,7 +104397,7 @@ static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){

     if( pList ){
       nArg = pList->nExpr;
       regAgg = sqlite3GetTempRange(pParse, nArg);
       sqlite3ExprCodeExprList(pParse, pList, regAgg, 1);
       sqlite3ExprCodeExprList(pParse, pList, regAgg, SQLITE_ECEL_DUP);
     }else{
       nArg = 0;
       regAgg = 0;

@@ -102189,7 +104443,7 @@ static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){

   ** values to an OP_Copy.
   */
   if( regHit ){
     addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit);
     addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);
   }
   sqlite3ExprCacheClear(pParse);
   for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){

@@ -102230,50 +104484,8 @@ static void explainSimpleCount(

 /*
 ** Generate code for the SELECT statement given in the p argument.
 **
 ** The results are distributed in various ways depending on the
 ** contents of the SelectDest structure pointed to by argument pDest
 ** as follows:
 **
 **     pDest->eDest    Result
 **     ------------    -------------------------------------------
 **     SRT_Output      Generate a row of output (using the OP_ResultRow
 **                     opcode) for each row in the result set.
 **
 **     SRT_Mem         Only valid if the result is a single column.
 **                     Store the first column of the first result row
 **                     in register pDest->iSDParm then abandon the rest
 **                     of the query.  This destination implies "LIMIT 1".
 **
 **     SRT_Set         The result must be a single column.  Store each
 **                     row of result as the key in table pDest->iSDParm.
 **                     Apply the affinity pDest->affSdst before storing
 **                     results.  Used to implement "IN (SELECT ...)".
 **
 **     SRT_Union       Store results as a key in a temporary table
 **                     identified by pDest->iSDParm.
 **
 **     SRT_Except      Remove results from the temporary table pDest->iSDParm.
 **
 **     SRT_Table       Store results in temporary table pDest->iSDParm.
 **                     This is like SRT_EphemTab except that the table
 **                     is assumed to already be open.
 **
 **     SRT_EphemTab    Create an temporary table pDest->iSDParm and store
 **                     the result there. The cursor is left open after
 **                     returning.  This is like SRT_Table except that
 **                     this destination uses OP_OpenEphemeral to create
 **                     the table first.
 **
 **     SRT_Coroutine   Generate a co-routine that returns a new row of
 **                     results each time it is invoked.  The entry point
 **                     of the co-routine is stored in register pDest->iSDParm.
 **
 **     SRT_Exists      Store a 1 in memory cell pDest->iSDParm if the result
 **                     set is not empty.
 **
 **     SRT_Discard     Throw the results away.  This is used by SELECT
 **                     statements within triggers whose only purpose is
 **                     the side-effects of functions.
 ** The results are returned according to the SelectDest structure.
 ** See comments in sqliteInt.h for further information.
 **
 ** This routine returns the number of errors.  If any errors are
 ** encountered, then an appropriate error message is left in

@@ -102390,42 +104602,24 @@ SQLITE_PRIVATE int sqlite3Select(

         p->selFlags |= SF_Aggregate;
       }
       i = -1;
     }else if( pTabList->nSrc==1 && (p->selFlags & SF_Materialize)==0
       && OptimizationEnabled(db, SQLITE_SubqCoroutine)
     }else if( pTabList->nSrc==1
            && OptimizationEnabled(db, SQLITE_SubqCoroutine)
     ){
       /* Implement a co-routine that will return a single row of the result
       ** set on each invocation.
       */
       int addrTop;
       int addrEof;
       int addrTop = sqlite3VdbeCurrentAddr(v)+1;
       pItem->regReturn = ++pParse->nMem;
       addrEof = ++pParse->nMem;
       /* Before coding the OP_Goto to jump to the start of the main routine,
       ** ensure that the jump to the verify-schema routine has already
       ** been coded. Otherwise, the verify-schema would likely be coded as
       ** part of the co-routine. If the main routine then accessed the
       ** database before invoking the co-routine for the first time (for
       ** example to initialize a LIMIT register from a sub-select), it would
       ** be doing so without having verified the schema version and obtained
       ** the required db locks. See ticket d6b36be38.  */
       sqlite3CodeVerifySchema(pParse, -1);
       sqlite3VdbeAddOp0(v, OP_Goto);
       addrTop = sqlite3VdbeAddOp1(v, OP_OpenPseudo, pItem->iCursor);
       sqlite3VdbeChangeP5(v, 1);
       VdbeComment((v, "coroutine for %s", pItem->pTab->zName));
       sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
       VdbeComment((v, "%s", pItem->pTab->zName));
       pItem->addrFillSub = addrTop;
       sqlite3VdbeAddOp2(v, OP_Integer, 0, addrEof);
       sqlite3VdbeChangeP5(v, 1);
       sqlite3SelectDestInit(&dest, SRT_Coroutine, pItem->regReturn);
       explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);
       sqlite3Select(pParse, pSub, &dest);
       pItem->pTab->nRowEst = (unsigned)pSub->nSelectRow;
       pItem->viaCoroutine = 1;
       sqlite3VdbeChangeP2(v, addrTop, dest.iSdst);
       sqlite3VdbeChangeP3(v, addrTop, dest.nSdst);
       sqlite3VdbeAddOp2(v, OP_Integer, 1, addrEof);
       sqlite3VdbeAddOp1(v, OP_Yield, pItem->regReturn);
       VdbeComment((v, "end %s", pItem->pTab->zName));
       pItem->regResult = dest.iSdst;
       sqlite3VdbeAddOp1(v, OP_EndCoroutine, pItem->regReturn);
       sqlite3VdbeJumpHere(v, addrTop-1);
       sqlite3ClearTempRegCache(pParse);
     }else{

@@ -102441,12 +104635,14 @@ SQLITE_PRIVATE int sqlite3Select(

       pItem->regReturn = ++pParse->nMem;
       topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
       pItem->addrFillSub = topAddr+1;
       VdbeNoopComment((v, "materialize %s", pItem->pTab->zName));
       if( pItem->isCorrelated==0 ){
         /* If the subquery is not correlated and if we are not inside of
         ** a trigger, then we only need to compute the value of the subquery
         ** once. */
         onceAddr = sqlite3CodeOnce(pParse);
         onceAddr = sqlite3CodeOnce(pParse); VdbeCoverage(v);
         VdbeComment((v, "materialize \"%s\"", pItem->pTab->zName));
       }else{
         VdbeNoopComment((v, "materialize \"%s\"", pItem->pTab->zName));
       }
       sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
       explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);

@@ -102478,21 +104674,6 @@ SQLITE_PRIVATE int sqlite3Select(

   /* If there is are a sequence of queries, do the earlier ones first.
   */
   if( p->pPrior ){
     if( p->pRightmost==0 ){
       Select *pLoop, *pRight = 0;
       int cnt = 0;
       int mxSelect;
       for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
         pLoop->pRightmost = p;
         pLoop->pNext = pRight;
         pRight = pLoop;
       }
       mxSelect = db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT];
       if( mxSelect && cnt>mxSelect ){
         sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
         goto select_end;
       }
     }
     rc = multiSelect(pParse, p, pDest);
     explainSetInteger(pParse->iSelectId, iRestoreSelectId);
     return rc;

@@ -102548,12 +104729,12 @@ SQLITE_PRIVATE int sqlite3Select(

   */
   if( pOrderBy ){
     KeyInfo *pKeyInfo;
     pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
     pKeyInfo = keyInfoFromExprList(pParse, pOrderBy, 0);
     pOrderBy->iECursor = pParse->nTab++;
     p->addrOpenEphm[2] = addrSortIndex =
       sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
                            pOrderBy->iECursor, pOrderBy->nExpr+2, 0,
                            (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
                            (char*)pKeyInfo, P4_KEYINFO);
   }else{
     addrSortIndex = -1;
   }

@@ -102580,8 +104761,8 @@ SQLITE_PRIVATE int sqlite3Select(

     sDistinct.tabTnct = pParse->nTab++;
     sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
                                 sDistinct.tabTnct, 0, 0,
                                 (char*)keyInfoFromExprList(pParse, p->pEList),
                                 P4_KEYINFO_HANDOFF);
                                 (char*)keyInfoFromExprList(pParse, p->pEList, 0),
                                 P4_KEYINFO);
     sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
     sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED;
   }else{

@@ -102614,7 +104795,7 @@ SQLITE_PRIVATE int sqlite3Select(

     }
     /* Use the standard inner loop. */
     selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, &sDistinct, pDest,
     selectInnerLoop(pParse, p, pEList, -1, pOrderBy, &sDistinct, pDest,
                     sqlite3WhereContinueLabel(pWInfo),
                     sqlite3WhereBreakLabel(pWInfo));

@@ -102644,10 +104825,10 @@ SQLITE_PRIVATE int sqlite3Select(

       struct ExprList_item *pItem;  /* For looping over expression in a list */
       for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
         pItem->iAlias = 0;
         pItem->u.x.iAlias = 0;
       }
       for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
         pItem->iAlias = 0;
         pItem->u.x.iAlias = 0;
       }
       if( p->nSelectRow>100 ) p->nSelectRow = 100;
     }else{

@@ -102666,6 +104847,7 @@ SQLITE_PRIVATE int sqlite3Select(

     sNC.pParse = pParse;
     sNC.pSrcList = pTabList;
     sNC.pAggInfo = &sAggInfo;
     sAggInfo.mnReg = pParse->nMem+1;
     sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0;
     sAggInfo.pGroupBy = pGroupBy;
     sqlite3ExprAnalyzeAggList(&sNC, pEList);

@@ -102680,6 +104862,7 @@ SQLITE_PRIVATE int sqlite3Select(

       sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->x.pList);
       sNC.ncFlags &= ~NC_InAggFunc;
     }
     sAggInfo.mxReg = pParse->nMem;
     if( db->mallocFailed ) goto select_end;
     /* Processing for aggregates with GROUP BY is very different and

@@ -102702,10 +104885,10 @@ SQLITE_PRIVATE int sqlite3Select(

       ** will be converted into a Noop.
       */
       sAggInfo.sortingIdx = pParse->nTab++;
       pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
       pKeyInfo = keyInfoFromExprList(pParse, pGroupBy, 0);
       addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen,
           sAggInfo.sortingIdx, sAggInfo.nSortingColumn,
 , (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
 , (char*)pKeyInfo, P4_KEYINFO);
       /* Initialize memory locations used by GROUP BY aggregate processing
       */

@@ -102794,7 +104977,7 @@ SQLITE_PRIVATE int sqlite3Select(

         sortOut = sqlite3GetTempReg(pParse);
         sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
         sqlite3VdbeAddOp2(v, OP_SorterSort, sAggInfo.sortingIdx, addrEnd);
         VdbeComment((v, "GROUP BY sort"));
         VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v);
         sAggInfo.useSortingIdx = 1;
         sqlite3ExprCacheClear(pParse);
       }

@@ -102819,9 +105002,9 @@ SQLITE_PRIVATE int sqlite3Select(

         }
       }
       sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
                           (char*)pKeyInfo, P4_KEYINFO);
                           (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
       j1 = sqlite3VdbeCurrentAddr(v);
       sqlite3VdbeAddOp3(v, OP_Jump, j1+1, 0, j1+1);
       sqlite3VdbeAddOp3(v, OP_Jump, j1+1, 0, j1+1); VdbeCoverage(v);
       /* Generate code that runs whenever the GROUP BY changes.
       ** Changes in the GROUP BY are detected by the previous code

@@ -102835,7 +105018,7 @@ SQLITE_PRIVATE int sqlite3Select(

       sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
       sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
       VdbeComment((v, "output one row"));
       sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd);
       sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v);
       VdbeComment((v, "check abort flag"));
       sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
       VdbeComment((v, "reset accumulator"));

@@ -102852,6 +105035,7 @@ SQLITE_PRIVATE int sqlite3Select(

       */
       if( groupBySort ){
         sqlite3VdbeAddOp2(v, OP_SorterNext, sAggInfo.sortingIdx, addrTopOfLoop);
         VdbeCoverage(v);
       }else{
         sqlite3WhereEnd(pWInfo);
         sqlite3VdbeChangeToNoop(v, addrSortingIdx);

@@ -102879,12 +105063,12 @@ SQLITE_PRIVATE int sqlite3Select(

       sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
       sqlite3VdbeResolveLabel(v, addrOutputRow);
       addrOutputRow = sqlite3VdbeCurrentAddr(v);
       sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
       sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2); VdbeCoverage(v);
       VdbeComment((v, "Groupby result generator entry point"));
       sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
       finalizeAggFunctions(pParse, &sAggInfo);
       sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
       selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy,
       selectInnerLoop(pParse, p, p->pEList, -1, pOrderBy,
                       &sDistinct, pDest,
                       addrOutputRow+1, addrSetAbort);
       sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);

@@ -102929,11 +105113,12 @@ SQLITE_PRIVATE int sqlite3Select(

         **
         ** (2011-04-15) Do not do a full scan of an unordered index.
         **
         ** (2013-10-03) Do not count the entires in a partial index.
         ** (2013-10-03) Do not count the entries in a partial index.
         **
         ** In practice the KeyInfo structure will not be used. It is only
         ** passed to keep OP_OpenRead happy.
         */
         if( !HasRowid(pTab) ) pBest = sqlite3PrimaryKeyIndex(pTab);
         for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
           if( pIdx->bUnordered==0
            && pIdx->szIdxRow<pTab->szTabRow

@@ -102945,13 +105130,13 @@ SQLITE_PRIVATE int sqlite3Select(

         }
         if( pBest ){
           iRoot = pBest->tnum;
           pKeyInfo = sqlite3IndexKeyinfo(pParse, pBest);
           pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
         }
         /* Open a read-only cursor, execute the OP_Count, close the cursor. */
         sqlite3VdbeAddOp3(v, OP_OpenRead, iCsr, iRoot, iDb);
         sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, iRoot, iDb, 1);
         if( pKeyInfo ){
           sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO_HANDOFF);
           sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
         }
         sqlite3VdbeAddOp2(v, OP_Count, iCsr, sAggInfo.aFunc[0].iMem);
         sqlite3VdbeAddOp1(v, OP_Close, iCsr);

@@ -103026,7 +105211,7 @@ SQLITE_PRIVATE int sqlite3Select(

       pOrderBy = 0;
       sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
       selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, 0,
       selectInnerLoop(pParse, p, p->pEList, -1, 0, 0,
                       pDest, addrEnd, addrEnd);
       sqlite3ExprListDelete(db, pDel);
     }

@@ -103151,10 +105336,6 @@ SQLITE_PRIVATE void sqlite3ExplainSelect(Vdbe *pVdbe, Select *p){

     sqlite3ExplainPrintf(pVdbe, "(null-select)");
     return;
   }
   while( p->pPrior ){
     p->pPrior->pNext = p;
     p = p->pPrior;
   }
   sqlite3ExplainPush(pVdbe);
   while( p ){
     explainOneSelect(pVdbe, p);

@@ -103770,25 +105951,21 @@ SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(

   sqlite3 *db,        /* The database connection */
   Token *pTableName,  /* Name of the table into which we insert */
   IdList *pColumn,    /* List of columns in pTableName to insert into */
   ExprList *pEList,   /* The VALUE clause: a list of values to be inserted */
   Select *pSelect,    /* A SELECT statement that supplies values */
   u8 orconf           /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
 ){
   TriggerStep *pTriggerStep;
   assert(pEList == 0 || pSelect == 0);
   assert(pEList != 0 || pSelect != 0 || db->mallocFailed);
   assert(pSelect != 0 || db->mallocFailed);
   pTriggerStep = triggerStepAllocate(db, TK_INSERT, pTableName);
   if( pTriggerStep ){
     pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
     pTriggerStep->pIdList = pColumn;
     pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
     pTriggerStep->orconf = orconf;
   }else{
     sqlite3IdListDelete(db, pColumn);
   }
   sqlite3ExprListDelete(db, pEList);
   sqlite3SelectDelete(db, pSelect);
   return pTriggerStep;

@@ -103943,6 +106120,7 @@ SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){

   assert( pTable!=0 );
   if( (v = sqlite3GetVdbe(pParse))!=0 ){
     int base;
     static const int iLn = VDBE_OFFSET_LINENO(2);
     static const VdbeOpList dropTrigger[] = {
       { OP_Rewind,     0, ADDR(9),  0},
       { OP_String8,    0, 1,        0}, /* 1 */

@@ -103957,7 +106135,7 @@ SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){

     sqlite3BeginWriteOperation(pParse, 0, iDb);
     sqlite3OpenMasterTable(pParse, iDb);
     base = sqlite3VdbeAddOpList(v,  ArraySize(dropTrigger), dropTrigger);
     base = sqlite3VdbeAddOpList(v,  ArraySize(dropTrigger), dropTrigger, iLn);
     sqlite3VdbeChangeP4(v, base+1, pTrigger->zName, P4_TRANSIENT);
     sqlite3VdbeChangeP4(v, base+4, "trigger", P4_STATIC);
     sqlite3ChangeCookie(pParse, iDb);

@@ -104103,15 +106281,7 @@ static int codeTriggerProgram(

     **   INSERT OR IGNORE INTO t1 ... ;  -- insert into t2 uses IGNORE policy
     */
     pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
     /* Clear the cookieGoto flag. When coding triggers, the cookieGoto
     ** variable is used as a flag to indicate to sqlite3ExprCodeConstants()
     ** that it is not safe to refactor constants (this happens after the
     ** start of the first loop in the SQL statement is coded - at that
     ** point code may be conditionally executed, so it is no longer safe to
     ** initialize constant register values).  */
     assert( pParse->cookieGoto==0 || pParse->cookieGoto==-1 );
     pParse->cookieGoto = 0;
     assert( pParse->okConstFactor==0 );
     switch( pStep->op ){
       case TK_UPDATE: {

@@ -104126,7 +106296,6 @@ static int codeTriggerProgram(

       case TK_INSERT: {
         sqlite3Insert(pParse,
           targetSrcList(pParse, pStep),
           sqlite3ExprListDup(db, pStep->pExprList, 0),
           sqlite3SelectDup(db, pStep->pSelect, 0),
           sqlite3IdListDup(db, pStep->pIdList),
           pParse->eOrconf

@@ -104157,7 +106326,7 @@ static int codeTriggerProgram(

   return 0;
 }
 #ifdef SQLITE_DEBUG
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
 /*
 ** This function is used to add VdbeComment() annotations to a VDBE
 ** program. It is not used in production code, only for debugging.

@@ -104297,6 +106466,7 @@ static TriggerPrg *codeRowTrigger(

   assert( !pSubParse->pAinc       && !pSubParse->pZombieTab );
   assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg );
   sqlite3ParserReset(pSubParse);
   sqlite3StackFree(db, pSubParse);
   return pPrg;

@@ -104582,7 +106752,7 @@ SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){

       sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);
     }
 #ifndef SQLITE_OMIT_FLOATING_POINT
     if( iReg>=0 && pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
     if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
       sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
     }
 #endif

@@ -104605,25 +106775,32 @@ SQLITE_PRIVATE void sqlite3Update(

 ){
   int i, j;              /* Loop counters */
   Table *pTab;           /* The table to be updated */
   int addr = 0;          /* VDBE instruction address of the start of the loop */
   int addrTop = 0;       /* VDBE instruction address of the start of the loop */
   WhereInfo *pWInfo;     /* Information about the WHERE clause */
   Vdbe *v;               /* The virtual database engine */
   Index *pIdx;           /* For looping over indices */
   Index *pPk;            /* The PRIMARY KEY index for WITHOUT ROWID tables */
   int nIdx;              /* Number of indices that need updating */
   int iCur;              /* VDBE Cursor number of pTab */
   int iBaseCur;          /* Base cursor number */
   int iDataCur;          /* Cursor for the canonical data btree */
   int iIdxCur;           /* Cursor for the first index */
   sqlite3 *db;           /* The database structure */
   int *aRegIdx = 0;      /* One register assigned to each index to be updated */
   int *aXRef = 0;        /* aXRef[i] is the index in pChanges->a[] of the
                          ** an expression for the i-th column of the table.
                          ** aXRef[i]==-1 if the i-th column is not changed. */
   int chngRowid;         /* True if the record number is being changed */
   u8 *aToOpen;           /* 1 for tables and indices to be opened */
   u8 chngPk;             /* PRIMARY KEY changed in a WITHOUT ROWID table */
   u8 chngRowid;          /* Rowid changed in a normal table */
   u8 chngKey;            /* Either chngPk or chngRowid */
   Expr *pRowidExpr = 0;  /* Expression defining the new record number */
   int openAll = 0;       /* True if all indices need to be opened */
   AuthContext sContext;  /* The authorization context */
   NameContext sNC;       /* The name-context to resolve expressions in */
   int iDb;               /* Database containing the table being updated */
   int okOnePass;         /* True for one-pass algorithm without the FIFO */
   int hasFK;             /* True if foreign key processing is required */
   int labelBreak;        /* Jump here to break out of UPDATE loop */
   int labelContinue;     /* Jump here to continue next step of UPDATE loop */
 #ifndef SQLITE_OMIT_TRIGGER
   int isView;            /* True when updating a view (INSTEAD OF trigger) */

@@ -104631,6 +106808,9 @@ SQLITE_PRIVATE void sqlite3Update(

   int tmask;             /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
 #endif
   int newmask;           /* Mask of NEW.* columns accessed by BEFORE triggers */
   int iEph = 0;          /* Ephemeral table holding all primary key values */
   int nKey = 0;          /* Number of elements in regKey for WITHOUT ROWID */
   int aiCurOnePass[2];   /* The write cursors opened by WHERE_ONEPASS */
   /* Register Allocations */
   int regRowCount = 0;   /* A count of rows changed */

@@ -104639,6 +106819,7 @@ SQLITE_PRIVATE void sqlite3Update(

   int regNew;            /* Content of the NEW.* table in triggers */
   int regOld = 0;        /* Content of OLD.* table in triggers */
   int regRowSet = 0;     /* Rowset of rows to be updated */
   int regKey = 0;        /* composite PRIMARY KEY value */
   memset(&sContext, 0, sizeof(sContext));
   db = pParse->db;

@@ -104676,20 +106857,34 @@ SQLITE_PRIVATE void sqlite3Update(

   if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
     goto update_cleanup;
   }
   aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
   if( aXRef==0 ) goto update_cleanup;
   for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
   /* Allocate a cursors for the main database table and for all indices.
   ** The index cursors might not be used, but if they are used they
   ** need to occur right after the database cursor.  So go ahead and
   ** allocate enough space, just in case.
   */
   pTabList->a[0].iCursor = iCur = pParse->nTab++;
   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
   pTabList->a[0].iCursor = iBaseCur = iDataCur = pParse->nTab++;
   iIdxCur = iDataCur+1;
   pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
   for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
     if( pIdx->autoIndex==2 && pPk!=0 ){
       iDataCur = pParse->nTab;
       pTabList->a[0].iCursor = iDataCur;
     }
     pParse->nTab++;
   }
   /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
   ** Initialize aXRef[] and aToOpen[] to their default values.
   */
   aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
   if( aXRef==0 ) goto update_cleanup;
   aRegIdx = aXRef+pTab->nCol;
   aToOpen = (u8*)(aRegIdx+nIdx);
   memset(aToOpen, 1, nIdx+1);
   aToOpen[nIdx+1] = 0;
   for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
   /* Initialize the name-context */
   memset(&sNC, 0, sizeof(sNC));
   sNC.pParse = pParse;

@@ -104701,7 +106896,7 @@ SQLITE_PRIVATE void sqlite3Update(

   ** column to be updated, make sure we have authorization to change
   ** that column.
   */
   chngRowid = 0;
   chngRowid = chngPk = 0;
   for(i=0; i<pChanges->nExpr; i++){
     if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
       goto update_cleanup;

@@ -104711,13 +106906,15 @@ SQLITE_PRIVATE void sqlite3Update(

         if( j==pTab->iPKey ){
           chngRowid = 1;
           pRowidExpr = pChanges->a[i].pExpr;
         }else if( pPk && (pTab->aCol[j].colFlags & COLFLAG_PRIMKEY)!=0 ){
           chngPk = 1;
         }
         aXRef[j] = i;
         break;
       }
     }
     if( j>=pTab->nCol ){
       if( sqlite3IsRowid(pChanges->a[i].zName) ){
       if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zName) ){
         j = -1;
         chngRowid = 1;
         pRowidExpr = pChanges->a[i].pExpr;

@@ -104741,32 +106938,36 @@ SQLITE_PRIVATE void sqlite3Update(

     }
 #endif
   }
   assert( (chngRowid & chngPk)==0 );
   assert( chngRowid==0 || chngRowid==1 );
   assert( chngPk==0 || chngPk==1 );
   chngKey = chngRowid + chngPk;
   /* The SET expressions are not actually used inside the WHERE loop.
   ** So reset the colUsed mask
   */
   pTabList->a[0].colUsed = 0;
   hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngRowid);
   hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
   /* Allocate memory for the array aRegIdx[].  There is one entry in the
   ** array for each index associated with table being updated.  Fill in
   ** the value with a register number for indices that are to be used
   ** and with zero for unused indices.
   /* There is one entry in the aRegIdx[] array for each index on the table
   ** being updated.  Fill in aRegIdx[] with a register number that will hold
   ** the key for accessing each index.
   */
   for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
   if( nIdx>0 ){
     aRegIdx = sqlite3DbMallocRaw(db, sizeof(Index*) * nIdx );
     if( aRegIdx==0 ) goto update_cleanup;
   }
   for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
     int reg;
     if( hasFK || chngRowid || pIdx->pPartIdxWhere ){
     if( chngKey || hasFK || pIdx->pPartIdxWhere || pIdx==pPk ){
       reg = ++pParse->nMem;
     }else{
       reg = 0;
       for(i=0; i<pIdx->nColumn; i++){
       for(i=0; i<pIdx->nKeyCol; i++){
         if( aXRef[pIdx->aiColumn[i]]>=0 ){
           reg = ++pParse->nMem;
           break;
         }
       }
     }
     if( reg==0 ) aToOpen[j+1] = 0;
     aRegIdx[j] = reg;
   }

@@ -104790,11 +106991,11 @@ SQLITE_PRIVATE void sqlite3Update(

   /* Allocate required registers. */
   regRowSet = ++pParse->nMem;
   regOldRowid = regNewRowid = ++pParse->nMem;
   if( pTrigger || hasFK ){
   if( chngPk || pTrigger || hasFK ){
     regOld = pParse->nMem + 1;
     pParse->nMem += pTab->nCol;
   }
   if( chngRowid || pTrigger || hasFK ){
   if( chngKey || pTrigger || hasFK ){
     regNewRowid = ++pParse->nMem;
   }
   regNew = pParse->nMem + 1;

@@ -104810,7 +107011,7 @@ SQLITE_PRIVATE void sqlite3Update(

   */
 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
   if( isView ){
     sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
     sqlite3MaterializeView(pParse, pTab, pWhere, iDataCur);
   }
 #endif

@@ -104823,24 +107024,58 @@ SQLITE_PRIVATE void sqlite3Update(

   /* Begin the database scan
   */
   sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
   pWInfo = sqlite3WhereBegin(
       pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED, 0
   );
   if( pWInfo==0 ) goto update_cleanup;
   okOnePass = sqlite3WhereOkOnePass(pWInfo);
   if( HasRowid(pTab) ){
     sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
     pWInfo = sqlite3WhereBegin(
         pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED, iIdxCur
     );
     if( pWInfo==0 ) goto update_cleanup;
     okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
     /* Remember the rowid of every item to be updated.
     */
     sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
     if( !okOnePass ){
       sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
     }
     /* End the database scan loop.
     */
     sqlite3WhereEnd(pWInfo);
   }else{
     int iPk;         /* First of nPk memory cells holding PRIMARY KEY value */
     i16 nPk;         /* Number of components of the PRIMARY KEY */
     int addrOpen;    /* Address of the OpenEphemeral instruction */
   /* Remember the rowid of every item to be updated.
   */
   sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regOldRowid);
   if( !okOnePass ){
     sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
     assert( pPk!=0 );
     nPk = pPk->nKeyCol;
     iPk = pParse->nMem+1;
     pParse->nMem += nPk;
     regKey = ++pParse->nMem;
     iEph = pParse->nTab++;
     sqlite3VdbeAddOp2(v, OP_Null, 0, iPk);
     addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nPk);
     sqlite3VdbeSetP4KeyInfo(pParse, pPk);
     pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0,
                                WHERE_ONEPASS_DESIRED, iIdxCur);
     if( pWInfo==0 ) goto update_cleanup;
     okOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
     for(i=0; i<nPk; i++){
       sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, pPk->aiColumn[i],
                                       iPk+i);
     }
     if( okOnePass ){
       sqlite3VdbeChangeToNoop(v, addrOpen);
       nKey = nPk;
       regKey = iPk;
     }else{
       sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey,
                         sqlite3IndexAffinityStr(v, pPk), nPk);
       sqlite3VdbeAddOp2(v, OP_IdxInsert, iEph, regKey);
     }
     sqlite3WhereEnd(pWInfo);
   }
   /* End the database scan loop.
   */
   sqlite3WhereEnd(pWInfo);
   /* Initialize the count of updated rows
   */
   if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){

@@ -104848,6 +107083,7 @@ SQLITE_PRIVATE void sqlite3Update(

     sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
   }
   labelBreak = sqlite3VdbeMakeLabel(v);
   if( !isView ){
     /*
     ** Open every index that needs updating.  Note that if any

@@ -104855,68 +107091,77 @@ SQLITE_PRIVATE void sqlite3Update(

     ** action, then we need to open all indices because we might need
     ** to be deleting some records.
     */
     if( !okOnePass ) sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
     if( onError==OE_Replace ){
       openAll = 1;
       memset(aToOpen, 1, nIdx+1);
     }else{
       openAll = 0;
       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
         if( pIdx->onError==OE_Replace ){
           openAll = 1;
           memset(aToOpen, 1, nIdx+1);
           break;
         }
       }
     }
     for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
       assert( aRegIdx );
       if( openAll || aRegIdx[i]>0 ){
         KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
         sqlite3VdbeAddOp4(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, iDb,
                        (char*)pKey, P4_KEYINFO_HANDOFF);
         assert( pParse->nTab>iCur+i+1 );
       }
     if( okOnePass ){
       if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
       if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
     }
     sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iBaseCur, aToOpen,
 , 0);
   }
   /* Top of the update loop */
   if( okOnePass ){
     int a1 = sqlite3VdbeAddOp1(v, OP_NotNull, regOldRowid);
     addr = sqlite3VdbeAddOp0(v, OP_Goto);
     sqlite3VdbeJumpHere(v, a1);
   }else{
     addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, 0, regOldRowid);
     if( aToOpen[iDataCur-iBaseCur] ){
       assert( pPk!=0 );
       sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey, nKey);
       VdbeCoverageNeverTaken(v);
     }
     labelContinue = labelBreak;
     sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
     VdbeCoverage(v);
   }else if( pPk ){
     labelContinue = sqlite3VdbeMakeLabel(v);
     sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
     addrTop = sqlite3VdbeAddOp2(v, OP_RowKey, iEph, regKey);
     sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey, 0);
     VdbeCoverage(v);
   }else{
     labelContinue = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, labelBreak,
                              regOldRowid);
     VdbeCoverage(v);
     sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
     VdbeCoverage(v);
   }
   /* Make cursor iCur point to the record that is being updated. If
   ** this record does not exist for some reason (deleted by a trigger,
   ** for example, then jump to the next iteration of the RowSet loop.  */
   sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
   /* If the record number will change, set register regNewRowid to
   ** contain the new value. If the record number is not being modified,
   ** then regNewRowid is the same register as regOldRowid, which is
   ** already populated.  */
   assert( chngRowid || pTrigger || hasFK || regOldRowid==regNewRowid );
   assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
   if( chngRowid ){
     sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
     sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid);
     sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v);
   }
   /* If there are triggers on this table, populate an array of registers
   ** with the required old.* column data.  */
   if( hasFK || pTrigger ){
   /* Compute the old pre-UPDATE content of the row being changed, if that
   ** information is needed */
   if( chngPk || hasFK || pTrigger ){
     u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
     oldmask |= sqlite3TriggerColmask(pParse,
         pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
     );
     for(i=0; i<pTab->nCol; i++){
       if( aXRef[i]<0 || oldmask==0xffffffff || (i<32 && (oldmask & (1<<i))) ){
         sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOld+i);
       if( oldmask==0xffffffff
        || (i<32 && (oldmask & MASKBIT32(i))!=0)
        || (pTab->aCol[i].colFlags & COLFLAG_PRIMKEY)!=0
       ){
         testcase(  oldmask!=0xffffffff && i==31 );
         sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regOld+i);
       }else{
         sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i);
       }
     }
     if( chngRowid==0 ){
     if( chngRowid==0 && pPk==0 ){
       sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
     }
   }

@@ -104937,15 +107182,15 @@ SQLITE_PRIVATE void sqlite3Update(

   newmask = sqlite3TriggerColmask(
       pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
   );
   sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);
   /*sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);*/
   for(i=0; i<pTab->nCol; i++){
     if( i==pTab->iPKey ){
       /*sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);*/
       sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);
     }else{
       j = aXRef[i];
       if( j>=0 ){
         sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
       }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask&(1<<i)) ){
       }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask & MASKBIT32(i)) ){
         /* This branch loads the value of a column that will not be changed
         ** into a register. This is done if there are no BEFORE triggers, or
         ** if there are one or more BEFORE triggers that use this value via

@@ -104953,8 +107198,9 @@ SQLITE_PRIVATE void sqlite3Update(

         */
         testcase( i==31 );
         testcase( i==32 );
         sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
         sqlite3ColumnDefault(v, pTab, i, regNew+i);
         sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i);
       }else{
         sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);
       }
     }
   }

@@ -104963,10 +107209,9 @@ SQLITE_PRIVATE void sqlite3Update(

   ** verified. One could argue that this is wrong.
   */
   if( tmask&TRIGGER_BEFORE ){
     sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
     sqlite3TableAffinityStr(v, pTab);
     sqlite3TableAffinity(v, pTab, regNew);
     sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
         TRIGGER_BEFORE, pTab, regOldRowid, onError, addr);
         TRIGGER_BEFORE, pTab, regOldRowid, onError, labelContinue);
     /* The row-trigger may have deleted the row being updated. In this
     ** case, jump to the next row. No updates or AFTER triggers are

@@ -104974,7 +107219,13 @@ SQLITE_PRIVATE void sqlite3Update(

     ** is deleted or renamed by a BEFORE trigger - is left undefined in the
     ** documentation.
     */
     sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
     if( pPk ){
       sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue,regKey,nKey);
       VdbeCoverage(v);
     }else{
       sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
       VdbeCoverage(v);
     }
     /* If it did not delete it, the row-trigger may still have modified
     ** some of the columns of the row being updated. Load the values for

@@ -104983,46 +107234,57 @@ SQLITE_PRIVATE void sqlite3Update(

     */
     for(i=0; i<pTab->nCol; i++){
       if( aXRef[i]<0 && i!=pTab->iPKey ){
         sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
         sqlite3ColumnDefault(v, pTab, i, regNew+i);
         sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, regNew+i);
       }
     }
   }
   if( !isView ){
     int j1;                       /* Address of jump instruction */
     int j1 = 0;           /* Address of jump instruction */
     int bReplace = 0;     /* True if REPLACE conflict resolution might happen */
     /* Do constraint checks. */
     sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,
         aRegIdx, (chngRowid?regOldRowid:0), 1, onError, addr, 0);
     assert( regOldRowid>0 );
     sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
         regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace);
     /* Do FK constraint checks. */
     if( hasFK ){
       sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngRowid);
       sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
     }
     /* Delete the index entries associated with the current record.  */
     j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);
     sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);
     if( bReplace || chngKey ){
       if( pPk ){
         j1 = sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, 0, regKey, nKey);
       }else{
         j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, 0, regOldRowid);
       }
       VdbeCoverageNeverTaken(v);
     }
     sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx);
     /* If changing the record number, delete the old record.  */
     if( hasFK || chngRowid ){
       sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0);
     if( hasFK || chngKey || pPk!=0 ){
       sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
     }
     if( bReplace || chngKey ){
       sqlite3VdbeJumpHere(v, j1);
     }
     sqlite3VdbeJumpHere(v, j1);
     if( hasFK ){
       sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngRowid);
       sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
     }
     /* Insert the new index entries and the new record. */
     sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, 0, 0);
     sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
                              regNewRowid, aRegIdx, 1, 0, 0);
     /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
     ** handle rows (possibly in other tables) that refer via a foreign key
     ** to the row just updated. */
     if( hasFK ){
       sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngRowid);
       sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
     }
   }

@@ -105033,22 +107295,29 @@ SQLITE_PRIVATE void sqlite3Update(

   }
   sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
       TRIGGER_AFTER, pTab, regOldRowid, onError, addr);
       TRIGGER_AFTER, pTab, regOldRowid, onError, labelContinue);
   /* Repeat the above with the next record to be updated, until
   ** all record selected by the WHERE clause have been updated.
   */
   sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
   sqlite3VdbeJumpHere(v, addr);
   if( okOnePass ){
     /* Nothing to do at end-of-loop for a single-pass */
   }else if( pPk ){
     sqlite3VdbeResolveLabel(v, labelContinue);
     sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
   }else{
     sqlite3VdbeAddOp2(v, OP_Goto, 0, labelContinue);
   }
   sqlite3VdbeResolveLabel(v, labelBreak);
   /* Close all tables */
   for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
     assert( aRegIdx );
     if( openAll || aRegIdx[i]>0 ){
       sqlite3VdbeAddOp2(v, OP_Close, iCur+i+1, 0);
     if( aToOpen[i+1] ){
       sqlite3VdbeAddOp2(v, OP_Close, iIdxCur+i, 0);
     }
   }
   sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);
   if( iDataCur<iIdxCur ) sqlite3VdbeAddOp2(v, OP_Close, iDataCur, 0);
   /* Update the sqlite_sequence table by storing the content of the
   ** maximum rowid counter values recorded while inserting into

@@ -105071,8 +107340,7 @@ SQLITE_PRIVATE void sqlite3Update(

 update_cleanup:
   sqlite3AuthContextPop(&sContext);
   sqlite3DbFree(db, aRegIdx);
   sqlite3DbFree(db, aXRef);
   sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */
   sqlite3SrcListDelete(db, pTabList);
   sqlite3ExprListDelete(db, pChanges);
   sqlite3ExprDelete(db, pWhere);

@@ -105165,7 +107433,7 @@ static void updateVirtualTable(

   /* Generate code to scan the ephemeral table and call VUpdate. */
   iReg = ++pParse->nMem;
   pParse->nMem += pTab->nCol+1;
   addr = sqlite3VdbeAddOp2(v, OP_Rewind, ephemTab, 0);
   addr = sqlite3VdbeAddOp2(v, OP_Rewind, ephemTab, 0); VdbeCoverage(v);
   sqlite3VdbeAddOp3(v, OP_Column,  ephemTab, 0, iReg);
   sqlite3VdbeAddOp3(v, OP_Column, ephemTab, (pRowid?1:0), iReg+1);
   for(i=0; i<pTab->nCol; i++){

@@ -105175,7 +107443,7 @@ static void updateVirtualTable(

   sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
   sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
   sqlite3MayAbort(pParse);
   sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1);
   sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
   sqlite3VdbeJumpHere(v, addr);
   sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);

@@ -105420,7 +107688,7 @@ SQLITE_PRIVATE int sqlite3RunVacuum(char **pzErrMsg, sqlite3 *db){

   rc = execExecSql(db, pzErrMsg,
       "SELECT 'CREATE TABLE vacuum_db.' || substr(sql,14) "
       "  FROM sqlite_master WHERE type='table' AND name!='sqlite_sequence'"
       "   AND rootpage>0"
       "   AND coalesce(rootpage,1)>0"
   );
   if( rc!=SQLITE_OK ) goto end_of_vacuum;
   rc = execExecSql(db, pzErrMsg,

@@ -105441,7 +107709,7 @@ SQLITE_PRIVATE int sqlite3RunVacuum(char **pzErrMsg, sqlite3 *db){

       "|| ' SELECT * FROM main.' || quote(name) || ';'"
       "FROM main.sqlite_master "
       "WHERE type = 'table' AND name!='sqlite_sequence' "
       "  AND rootpage>0"
       "  AND coalesce(rootpage,1)>0"
   );
   if( rc!=SQLITE_OK ) goto end_of_vacuum;

@@ -106295,6 +108563,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){

       sqlite3VdbeFinalize(pParse->pVdbe);
     }
     sqlite3DeleteTable(db, pParse->pNewTable);
     sqlite3ParserReset(pParse);
     sqlite3StackFree(db, pParse);
   }

@@ -106672,7 +108941,24 @@ SQLITE_API int sqlite3_vtab_config(sqlite3 *db, int op, ...){

 ** so is applicable.  Because this module is responsible for selecting
 ** indices, you might also think of this module as the "query optimizer".
 */
 /************** Include whereInt.h in the middle of where.c ******************/
 /************** Begin file whereInt.h ****************************************/
 /*
 ** 2013-11-12
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 **
 ** This file contains structure and macro definitions for the query
 ** planner logic in "where.c".  These definitions are broken out into
 ** a separate source file for easier editing.
 */
 /*
 ** Trace output macros

@@ -106724,11 +109010,12 @@ struct WhereLevel {

   int iIdxCur;          /* The VDBE cursor used to access pIdx */
   int addrBrk;          /* Jump here to break out of the loop */
   int addrNxt;          /* Jump here to start the next IN combination */
   int addrSkip;         /* Jump here for next iteration of skip-scan */
   int addrCont;         /* Jump here to continue with the next loop cycle */
   int addrFirst;        /* First instruction of interior of the loop */
   int addrBody;         /* Beginning of the body of this loop */
   u8 iFrom;             /* Which entry in the FROM clause */
   u8 op, p5;            /* Opcode and P5 of the opcode that ends the loop */
   u8 op, p3, p5;        /* Opcode, P3 & P5 of the opcode that ends the loop */
   int p1, p2;           /* Operands of the opcode used to ends the loop */
   union {               /* Information that depends on pWLoop->wsFlags */
     struct {

@@ -106772,7 +109059,8 @@ struct WhereLoop {

   LogEst nOut;          /* Estimated number of output rows */
   union {
     struct {               /* Information for internal btree tables */
       int nEq;               /* Number of equality constraints */
       u16 nEq;               /* Number of equality constraints */
       u16 nSkip;             /* Number of initial index columns to skip */
       Index *pIndex;         /* Index used, or NULL */
     } btree;
     struct {               /* Information for virtual tables */

@@ -107064,6 +109352,7 @@ struct WhereInfo {

   int iContinue;            /* Jump here to continue with next record */
   int iBreak;               /* Jump here to break out of the loop */
   int savedNQueryLoop;      /* pParse->nQueryLoop outside the WHERE loop */
   int aiCurOnePass[2];      /* OP_OpenWrite cursors for the ONEPASS opt */
   WhereMaskSet sMaskSet;    /* Map cursor numbers to bitmasks */
   WhereClause sWC;          /* Decomposition of the WHERE clause */
   WhereLevel a[1];          /* Information about each nest loop in WHERE */

@@ -107112,6 +109401,11 @@ struct WhereInfo {

 #define WHERE_ONEROW       0x00001000  /* Selects no more than one row */
 #define WHERE_MULTI_OR     0x00002000  /* OR using multiple indices */
 #define WHERE_AUTO_INDEX   0x00004000  /* Uses an ephemeral index */
 #define WHERE_SKIPSCAN     0x00008000  /* Uses the skip-scan algorithm */
 #define WHERE_UNQ_WANTED   0x00010000  /* WHERE_ONEROW would have been helpful*/
 /************** End of whereInt.h ********************************************/
 /************** Continuing where we left off in where.c **********************/
 /*
 ** Return the estimated number of output rows from a WHERE clause

@@ -107156,8 +109450,19 @@ SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo *pWInfo){

 ** Return TRUE if an UPDATE or DELETE statement can operate directly on
 ** the rowids returned by a WHERE clause.  Return FALSE if doing an
 ** UPDATE or DELETE might change subsequent WHERE clause results.
 **
 ** If the ONEPASS optimization is used (if this routine returns true)
 ** then also write the indices of open cursors used by ONEPASS
 ** into aiCur[0] and aiCur[1].  iaCur[0] gets the cursor of the data
 ** table and iaCur[1] gets the cursor used by an auxiliary index.
 ** Either value may be -1, indicating that cursor is not used.
 ** Any cursors returned will have been opened for writing.
 **
 ** aiCur[0] and aiCur[1] both get -1 if the where-clause logic is
 ** unable to use the ONEPASS optimization.
 */
 SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo *pWInfo){
 SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo *pWInfo, int *aiCur){
   memcpy(aiCur, pWInfo->aiCurOnePass, sizeof(int)*2);
   return pWInfo->okOnePass;
 }

@@ -107533,7 +109838,10 @@ static WhereTerm *whereScanNext(WhereScan *pScan){

     iColumn = pScan->aEquiv[pScan->iEquiv-1];
     while( (pWC = pScan->pWC)!=0 ){
       for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){
         if( pTerm->leftCursor==iCur && pTerm->u.leftColumn==iColumn ){
         if( pTerm->leftCursor==iCur
          && pTerm->u.leftColumn==iColumn
          && (pScan->iEquiv<=2 || !ExprHasProperty(pTerm->pExpr, EP_FromJoin))
         ){
           if( (pTerm->eOperator & WO_EQUIV)!=0
            && pScan->nEquiv<ArraySize(pScan->aEquiv)
           ){

@@ -107623,7 +109931,7 @@ static WhereTerm *whereScanInit(

   if( pIdx && iColumn>=0 ){
     pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity;
     for(j=0; pIdx->aiColumn[j]!=iColumn; j++){
       if( NEVER(j>=pIdx->nColumn) ) return 0;
       if( NEVER(j>=pIdx->nKeyCol) ) return 0;
     }
     pScan->zCollName = pIdx->azColl[j];
   }else{

@@ -107747,11 +110055,8 @@ static int isLikeOrGlob(

   }
   assert( pLeft->iColumn!=(-1) ); /* Because IPK never has AFF_TEXT */
   pRight = pList->a[0].pExpr;
   pRight = sqlite3ExprSkipCollate(pList->a[0].pExpr);
   op = pRight->op;
   if( op==TK_REGISTER ){
     op = pRight->op2;
   }
   if( op==TK_VARIABLE ){
     Vdbe *pReprepare = pParse->pReprepare;
     int iCol = pRight->iColumn;

@@ -108553,16 +110858,16 @@ static int isDistinctRedundant(

   */
   for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
     if( pIdx->onError==OE_None ) continue;
     for(i=0; i<pIdx->nColumn; i++){
       int iCol = pIdx->aiColumn[i];
     for(i=0; i<pIdx->nKeyCol; i++){
       i16 iCol = pIdx->aiColumn[i];
       if( 0==findTerm(pWC, iBase, iCol, ~(Bitmask)0, WO_EQ, pIdx) ){
         int iIdxCol = findIndexCol(pParse, pDistinct, iBase, pIdx, i);
         if( iIdxCol<0 || pTab->aCol[pIdx->aiColumn[i]].notNull==0 ){
         if( iIdxCol<0 || pTab->aCol[iCol].notNull==0 ){
           break;
         }
       }
     }
     if( i==pIdx->nColumn ){
     if( i==pIdx->nKeyCol ){
       /* This index implies that the DISTINCT qualifier is redundant. */
       return 1;
     }

@@ -108618,6 +110923,7 @@ static void TRACE_IDX_OUTPUTS(sqlite3_index_info *p){

   sqlite3DebugPrintf("  idxStr=%s\n", p->idxStr);
   sqlite3DebugPrintf("  orderByConsumed=%d\n", p->orderByConsumed);
   sqlite3DebugPrintf("  estimatedCost=%g\n", p->estimatedCost);
   sqlite3DebugPrintf("  estimatedRows=%lld\n", p->estimatedRows);
 }
 #else
 #define TRACE_IDX_INPUTS(A)

@@ -108660,15 +110966,13 @@ static void constructAutomaticIndex(

   Bitmask notReady,           /* Mask of cursors that are not available */
   WhereLevel *pLevel          /* Write new index here */
 ){
   int nColumn;                /* Number of columns in the constructed index */
   int nKeyCol;                /* Number of columns in the constructed index */
   WhereTerm *pTerm;           /* A single term of the WHERE clause */
   WhereTerm *pWCEnd;          /* End of pWC->a[] */
   int nByte;                  /* Byte of memory needed for pIdx */
   Index *pIdx;                /* Object describing the transient index */
   Vdbe *v;                    /* Prepared statement under construction */
   int addrInit;               /* Address of the initialization bypass jump */
   Table *pTable;              /* The table being indexed */
   KeyInfo *pKeyinfo;          /* Key information for the index */
   int addrTop;                /* Top of the index fill loop */
   int regRecord;              /* Register holding an index record */
   int n;                      /* Column counter */

@@ -108676,6 +110980,7 @@ static void constructAutomaticIndex(

   int mxBitCol;               /* Maximum column in pSrc->colUsed */
   CollSeq *pColl;             /* Collating sequence to on a column */
   WhereLoop *pLoop;           /* The Loop object */
   char *zNotUsed;             /* Extra space on the end of pIdx */
   Bitmask idxCols;            /* Bitmap of columns used for indexing */
   Bitmask extraCols;          /* Bitmap of additional columns */
   u8 sentWarning = 0;         /* True if a warnning has been issued */

@@ -108684,11 +110989,11 @@ static void constructAutomaticIndex(

   ** transient index on 2nd and subsequent iterations of the loop. */
   v = pParse->pVdbe;
   assert( v!=0 );
   addrInit = sqlite3CodeOnce(pParse);
   addrInit = sqlite3CodeOnce(pParse); VdbeCoverage(v);
   /* Count the number of columns that will be added to the index
   ** and used to match WHERE clause constraints */
   nColumn = 0;
   nKeyCol = 0;
   pTable = pSrc->pTab;
   pWCEnd = &pWC->a[pWC->nTerm];
   pLoop = pLevel->pWLoop;

@@ -108706,14 +111011,14 @@ static void constructAutomaticIndex(

         sentWarning = 1;
       }
       if( (idxCols & cMask)==0 ){
         if( whereLoopResize(pParse->db, pLoop, nColumn+1) ) return;
         pLoop->aLTerm[nColumn++] = pTerm;
         if( whereLoopResize(pParse->db, pLoop, nKeyCol+1) ) return;
         pLoop->aLTerm[nKeyCol++] = pTerm;
         idxCols |= cMask;
       }
     }
   }
   assert( nColumn>0 );
   pLoop->u.btree.nEq = pLoop->nLTerm = nColumn;
   assert( nKeyCol>0 );
   pLoop->u.btree.nEq = pLoop->nLTerm = nKeyCol;
   pLoop->wsFlags = WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WHERE_INDEXED
                      | WHERE_AUTO_INDEX;

@@ -108730,26 +111035,18 @@ static void constructAutomaticIndex(

   testcase( pTable->nCol==BMS-1 );
   testcase( pTable->nCol==BMS-2 );
   for(i=0; i<mxBitCol; i++){
     if( extraCols & MASKBIT(i) ) nColumn++;
     if( extraCols & MASKBIT(i) ) nKeyCol++;
   }
   if( pSrc->colUsed & MASKBIT(BMS-1) ){
     nColumn += pTable->nCol - BMS + 1;
     nKeyCol += pTable->nCol - BMS + 1;
   }
   pLoop->wsFlags |= WHERE_COLUMN_EQ | WHERE_IDX_ONLY;
   /* Construct the Index object to describe this index */
   nByte = sizeof(Index);
   nByte += nColumn*sizeof(int);     /* Index.aiColumn */
   nByte += nColumn*sizeof(char*);   /* Index.azColl */
   nByte += nColumn;                 /* Index.aSortOrder */
   pIdx = sqlite3DbMallocZero(pParse->db, nByte);
   pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+1, 0, &zNotUsed);
   if( pIdx==0 ) return;
   pLoop->u.btree.pIndex = pIdx;
   pIdx->azColl = (char**)&pIdx[1];
   pIdx->aiColumn = (int*)&pIdx->azColl[nColumn];
   pIdx->aSortOrder = (u8*)&pIdx->aiColumn[nColumn];
   pIdx->zName = "auto-index";
   pIdx->nColumn = nColumn;
   pIdx->pTable = pTable;
   n = 0;
   idxCols = 0;

@@ -108787,23 +111084,24 @@ static void constructAutomaticIndex(

       n++;
     }
   }
   assert( n==nColumn );
   assert( n==nKeyCol );
   pIdx->aiColumn[n] = -1;
   pIdx->azColl[n] = "BINARY";
   /* Create the automatic index */
   pKeyinfo = sqlite3IndexKeyinfo(pParse, pIdx);
   assert( pLevel->iIdxCur>=0 );
   pLevel->iIdxCur = pParse->nTab++;
   sqlite3VdbeAddOp4(v, OP_OpenAutoindex, pLevel->iIdxCur, nColumn+1, 0,
                     (char*)pKeyinfo, P4_KEYINFO_HANDOFF);
   sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1);
   sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
   VdbeComment((v, "for %s", pTable->zName));
   /* Fill the automatic index with content */
   addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur);
   addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v);
   regRecord = sqlite3GetTempReg(pParse);
   sqlite3GenerateIndexKey(pParse, pIdx, pLevel->iTabCur, regRecord, 1, 0);
   sqlite3GenerateIndexKey(pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0);
   sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord);
   sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
   sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1);
   sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v);
   sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX);
   sqlite3VdbeJumpHere(v, addrTop);
   sqlite3ReleaseTempReg(pParse, regRecord);

@@ -108841,7 +111139,8 @@ static sqlite3_index_info *allocateIndexInfo(

     assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
     testcase( pTerm->eOperator & WO_IN );
     testcase( pTerm->eOperator & WO_ISNULL );
     if( pTerm->eOperator & (WO_ISNULL) ) continue;
     testcase( pTerm->eOperator & WO_ALL );
     if( (pTerm->eOperator & ~(WO_ISNULL|WO_EQUIV))==0 ) continue;
     if( pTerm->wtFlags & TERM_VNULL ) continue;
     nTerm++;
   }

@@ -108893,7 +111192,8 @@ static sqlite3_index_info *allocateIndexInfo(

     assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) );
     testcase( pTerm->eOperator & WO_IN );
     testcase( pTerm->eOperator & WO_ISNULL );
     if( pTerm->eOperator & (WO_ISNULL) ) continue;
     testcase( pTerm->eOperator & WO_ALL );
     if( (pTerm->eOperator & ~(WO_ISNULL|WO_EQUIV))==0 ) continue;
     if( pTerm->wtFlags & TERM_VNULL ) continue;
     pIdxCons[j].iColumn = pTerm->u.leftColumn;
     pIdxCons[j].iTermOffset = i;

@@ -108995,14 +111295,13 @@ static void whereKeyStats(

 #ifndef SQLITE_DEBUG
   UNUSED_PARAMETER( pParse );
 #endif
   assert( pRec!=0 || pParse->db->mallocFailed );
   if( pRec==0 ) return;
   assert( pRec!=0 );
   iCol = pRec->nField - 1;
   assert( pIdx->nSample>0 );
   assert( pRec->nField>0 && iCol<pIdx->nSampleCol );
   do{
     iTest = (iMin+i)/2;
     res = sqlite3VdbeRecordCompare(aSample[iTest].n, aSample[iTest].p, pRec);
     res = sqlite3VdbeRecordCompare(aSample[iTest].n, aSample[iTest].p, pRec, 0);
     if( res<0 ){
       iMin = iTest+1;
     }else{

@@ -109017,16 +111316,16 @@ static void whereKeyStats(

   if( res==0 ){
     /* If (res==0) is true, then sample $i must be equal to pRec */
     assert( i<pIdx->nSample );
     assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)
     assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec, 0)
          || pParse->db->mallocFailed );
   }else{
     /* Otherwise, pRec must be smaller than sample $i and larger than
     ** sample ($i-1).  */
     assert( i==pIdx->nSample
          || sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)>0
          || sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec, 0)>0
          || pParse->db->mallocFailed );
     assert( i==0
          || sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0
          || sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec, 0)<0
          || pParse->db->mallocFailed );
   }
 #endif /* ifdef SQLITE_DEBUG */

@@ -109047,7 +111346,7 @@ static void whereKeyStats(

       iUpper = i>=pIdx->nSample ? pIdx->aiRowEst[0] : aSample[i].anLt[iCol];
       iLower = aSample[i-1].anEq[iCol] + aSample[i-1].anLt[iCol];
     }
     aStat[1] = (pIdx->nColumn>iCol ? pIdx->aAvgEq[iCol] : 1);
     aStat[1] = (pIdx->nKeyCol>iCol ? pIdx->aAvgEq[iCol] : 1);
     if( iLower>=iUpper ){
       iGap = 0;
     }else{

@@ -109147,7 +111446,7 @@ static int whereRangeScanEst(

     tRowcnt iLower;
     tRowcnt iUpper;
     if( nEq==p->nColumn ){
     if( nEq==p->nKeyCol ){
       aff = SQLITE_AFF_INTEGER;
     }else{
       aff = p->pTable->aCol[p->aiColumn[nEq]].affinity;

@@ -109205,7 +111504,7 @@ static int whereRangeScanEst(

         nOut = nNew;
       }
       pLoop->nOut = (LogEst)nOut;
       WHERETRACE(0x100, ("range scan regions: %u..%u  est=%d\n",
       WHERETRACE(0x10, ("range scan regions: %u..%u  est=%d\n",
                          (u32)iLower, (u32)iUpper, nOut));
       return SQLITE_OK;
     }

@@ -109265,7 +111564,7 @@ static int whereEqualScanEst(

   int bOk;
   assert( nEq>=1 );
   assert( nEq<=(p->nColumn+1) );
   assert( nEq<=(p->nKeyCol+1) );
   assert( p->aSample!=0 );
   assert( p->nSample>0 );
   assert( pBuilder->nRecValid<nEq );

@@ -109278,7 +111577,7 @@ static int whereEqualScanEst(

   /* This is an optimization only. The call to sqlite3Stat4ProbeSetValue()
   ** below would return the same value.  */
   if( nEq>p->nColumn ){
   if( nEq>p->nKeyCol ){
     *pnRow = 1;
     return SQLITE_OK;
   }

@@ -109291,7 +111590,7 @@ static int whereEqualScanEst(

   pBuilder->nRecValid = nEq;
   whereKeyStats(pParse, p, pRec, 0, a);
   WHERETRACE(0x100,("equality scan regions: %d\n", (int)a[1]));
   WHERETRACE(0x10,("equality scan regions: %d\n", (int)a[1]));
   *pnRow = a[1];
   return rc;

@@ -109339,7 +111638,7 @@ static int whereInScanEst(

   if( rc==SQLITE_OK ){
     if( nRowEst > p->aiRowEst[0] ) nRowEst = p->aiRowEst[0];
     *pnRow = nRowEst;
     WHERETRACE(0x100,("IN row estimate: est=%g\n", nRowEst));
     WHERETRACE(0x10,("IN row estimate: est=%g\n", nRowEst));
   }
   assert( pBuilder->nRecValid==nRecValid );
   return rc;

@@ -109478,6 +111777,8 @@ static int codeEqualityTerm(

     }
     iTab = pX->iTable;
     sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0);
     VdbeCoverageIf(v, bRev);
     VdbeCoverageIf(v, !bRev);
     assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
     pLoop->wsFlags |= WHERE_IN_ABLE;
     if( pLevel->u.in.nIn==0 ){

@@ -109496,8 +111797,8 @@ static int codeEqualityTerm(

       }else{
         pIn->addrInTop = sqlite3VdbeAddOp3(v, OP_Column, iTab, 0, iReg);
       }
       pIn->eEndLoopOp = bRev ? OP_Prev : OP_Next;
       sqlite3VdbeAddOp1(v, OP_IsNull, iReg);
       pIn->eEndLoopOp = bRev ? OP_PrevIfOpen : OP_NextIfOpen;
       sqlite3VdbeAddOp1(v, OP_IsNull, iReg); VdbeCoverage(v);
     }else{
       pLevel->u.in.nIn = 0;
     }

@@ -109509,7 +111810,7 @@ static int codeEqualityTerm(

 /*
 ** Generate code that will evaluate all == and IN constraints for an
 ** index.
 ** index scan.
 **
 ** For example, consider table t1(a,b,c,d,e,f) with index i1(a,b,c).
 ** Suppose the WHERE clause is this:  a==5 AND b IN (1,2,3) AND c>5 AND c<10

@@ -109524,9 +111825,15 @@ static int codeEqualityTerm(

 ** The only thing it does is allocate the pLevel->iMem memory cell and
 ** compute the affinity string.
 **
 ** This routine always allocates at least one memory cell and returns
 ** the index of that memory cell. The code that
 ** calls this routine will use that memory cell to store the termination
 ** The nExtraReg parameter is 0 or 1.  It is 0 if all WHERE clause constraints
 ** are == or IN and are covered by the nEq.  nExtraReg is 1 if there is
 ** an inequality constraint (such as the "c>=5 AND c<10" in the example) that
 ** occurs after the nEq quality constraints.
 **
 ** This routine allocates a range of nEq+nExtraReg memory cells and returns
 ** the index of the first memory cell in that range. The code that
 ** calls this routine will use that memory range to store keys for
 ** start and termination conditions of the loop.
 ** key value of the loop.  If one or more IN operators appear, then
 ** this routine allocates an additional nEq memory cells for internal
 ** use.

@@ -109553,7 +111860,8 @@ static int codeAllEqualityTerms(

   int nExtraReg,        /* Number of extra registers to allocate */
   char **pzAff          /* OUT: Set to point to affinity string */
 ){
   int nEq;                      /* The number of == or IN constraints to code */
   u16 nEq;                      /* The number of == or IN constraints to code */
   u16 nSkip;                    /* Number of left-most columns to skip */
   Vdbe *v = pParse->pVdbe;      /* The vm under construction */
   Index *pIdx;                  /* The index being used for this loop */
   WhereTerm *pTerm;             /* A single constraint term */

@@ -109567,6 +111875,7 @@ static int codeAllEqualityTerms(

   pLoop = pLevel->pWLoop;
   assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 );
   nEq = pLoop->u.btree.nEq;
   nSkip = pLoop->u.btree.nSkip;
   pIdx = pLoop->u.btree.pIndex;
   assert( pIdx!=0 );

@@ -109581,14 +111890,33 @@ static int codeAllEqualityTerms(

     pParse->db->mallocFailed = 1;
   }
   if( nSkip ){
     int iIdxCur = pLevel->iIdxCur;
     sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur);
     VdbeCoverageIf(v, bRev==0);
     VdbeCoverageIf(v, bRev!=0);
     VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
     j = sqlite3VdbeAddOp0(v, OP_Goto);
     pLevel->addrSkip = sqlite3VdbeAddOp4Int(v, (bRev?OP_SeekLT:OP_SeekGT),
                             iIdxCur, 0, regBase, nSkip);
     VdbeCoverageIf(v, bRev==0);
     VdbeCoverageIf(v, bRev!=0);
     sqlite3VdbeJumpHere(v, j);
     for(j=0; j<nSkip; j++){
       sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, j, regBase+j);
       assert( pIdx->aiColumn[j]>=0 );
       VdbeComment((v, "%s", pIdx->pTable->aCol[pIdx->aiColumn[j]].zName));
     }
   }
   /* Evaluate the equality constraints
   */
   assert( zAff==0 || (int)strlen(zAff)>=nEq );
   for(j=0; j<nEq; j++){
   for(j=nSkip; j<nEq; j++){
     int r1;
     pTerm = pLoop->aLTerm[j];
     assert( pTerm!=0 );
     /* The following true for indices with redundant columns.
     /* The following testcase is true for indices with redundant columns.
     ** Ex: CREATE INDEX i1 ON t1(a,b,a); SELECT * FROM t1 WHERE a=0 AND b=0; */
     testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
     testcase( pTerm->wtFlags & TERM_VIRTUAL );

@@ -109605,7 +111933,10 @@ static int codeAllEqualityTerms(

     testcase( pTerm->eOperator & WO_IN );
     if( (pTerm->eOperator & (WO_ISNULL|WO_IN))==0 ){
       Expr *pRight = pTerm->pExpr->pRight;
       sqlite3ExprCodeIsNullJump(v, pRight, regBase+j, pLevel->addrBrk);
       if( sqlite3ExprCanBeNull(pRight) ){
         sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
         VdbeCoverage(v);
       }
       if( zAff ){
         if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_NONE ){
           zAff[j] = SQLITE_AFF_NONE;

@@ -109636,7 +111967,7 @@ static void explainAppendTerm(

   const char *zOp             /* Name of the operator */
 ){
   if( iTerm ) sqlite3StrAccumAppend(pStr, " AND ", 5);
   sqlite3StrAccumAppend(pStr, zColumn, -1);
   sqlite3StrAccumAppendAll(pStr, zColumn);
   sqlite3StrAccumAppend(pStr, zOp, 1);
   sqlite3StrAccumAppend(pStr, "?", 1);
 }

@@ -109662,10 +111993,11 @@ static void explainAppendTerm(

 */
 static char *explainIndexRange(sqlite3 *db, WhereLoop *pLoop, Table *pTab){
   Index *pIndex = pLoop->u.btree.pIndex;
   int nEq = pLoop->u.btree.nEq;
   u16 nEq = pLoop->u.btree.nEq;
   u16 nSkip = pLoop->u.btree.nSkip;
   int i, j;
   Column *aCol = pTab->aCol;
   int *aiColumn = pIndex->aiColumn;
   i16 *aiColumn = pIndex->aiColumn;
   StrAccum txt;
   if( nEq==0 && (pLoop->wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ){

@@ -109675,17 +112007,24 @@ static char *explainIndexRange(sqlite3 *db, WhereLoop *pLoop, Table *pTab){

   txt.db = db;
   sqlite3StrAccumAppend(&txt, " (", 2);
   for(i=0; i<nEq; i++){
     char *z = (i==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[i]].zName;
     explainAppendTerm(&txt, i, z, "=");
     char *z = (i==pIndex->nKeyCol ) ? "rowid" : aCol[aiColumn[i]].zName;
     if( i>=nSkip ){
       explainAppendTerm(&txt, i, z, "=");
     }else{
       if( i ) sqlite3StrAccumAppend(&txt, " AND ", 5);
       sqlite3StrAccumAppend(&txt, "ANY(", 4);
       sqlite3StrAccumAppendAll(&txt, z);
       sqlite3StrAccumAppend(&txt, ")", 1);
     }
   }
   j = i;
   if( pLoop->wsFlags&WHERE_BTM_LIMIT ){
     char *z = (j==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[j]].zName;
     char *z = (j==pIndex->nKeyCol ) ? "rowid" : aCol[aiColumn[j]].zName;
     explainAppendTerm(&txt, i++, z, ">");
   }
   if( pLoop->wsFlags&WHERE_TOP_LIMIT ){
     char *z = (j==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[j]].zName;
     char *z = (j==pIndex->nKeyCol ) ? "rowid" : aCol[aiColumn[j]].zName;
     explainAppendTerm(&txt, i, z, "<");
   }
   sqlite3StrAccumAppend(&txt, ")", 1);

@@ -109706,7 +112045,10 @@ static void explainOneScan(

   int iFrom,                      /* Value for "from" column of output */
   u16 wctrlFlags                  /* Flags passed to sqlite3WhereBegin() */
 ){
   if( pParse->explain==2 ){
 #ifndef SQLITE_DEBUG
   if( pParse->explain==2 )
 #endif
   {
     struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom];
     Vdbe *v = pParse->pVdbe;      /* VM being constructed */
     sqlite3 *db = pParse->db;     /* Database handle */

@@ -109812,7 +112154,7 @@ static Bitmask codeOneLoopStart(

   bRev = (pWInfo->revMask>>iLevel)&1;
   omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0
            && (pWInfo->wctrlFlags & WHERE_FORCE_TABLE)==0;
   VdbeNoopComment((v, "Begin Join Loop %d", iLevel));
   VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
   /* Create labels for the "break" and "continue" instructions
   ** for the current loop.  Jump to addrBrk to break out of a loop.

@@ -109840,10 +112182,10 @@ static Bitmask codeOneLoopStart(

   /* Special case of a FROM clause subquery implemented as a co-routine */
   if( pTabItem->viaCoroutine ){
     int regYield = pTabItem->regReturn;
     sqlite3VdbeAddOp2(v, OP_Integer, pTabItem->addrFillSub-1, regYield);
     pLevel->p2 =  sqlite3VdbeAddOp1(v, OP_Yield, regYield);
     VdbeComment((v, "next row of co-routine %s", pTabItem->pTab->zName));
     sqlite3VdbeAddOp2(v, OP_If, regYield+1, addrBrk);
     sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
     pLevel->p2 =  sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk);
     VdbeCoverage(v);
     VdbeComment((v, "next row of \"%s\"", pTabItem->pTab->zName));
     pLevel->op = OP_Goto;
   }else

@@ -109875,6 +112217,7 @@ static Bitmask codeOneLoopStart(

     sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg,
                       pLoop->u.vtab.idxStr,
                       pLoop->u.vtab.needFree ? P4_MPRINTF : P4_STATIC);
     VdbeCoverage(v);
     pLoop->u.vtab.needFree = 0;
     for(j=0; j<nConstraint && j<16; j++){
       if( (pLoop->u.vtab.omitMask>>j)&1 ){

@@ -109898,16 +112241,18 @@ static Bitmask codeOneLoopStart(

     **          construct.
     */
     assert( pLoop->u.btree.nEq==1 );
     iReleaseReg = sqlite3GetTempReg(pParse);
     pTerm = pLoop->aLTerm[0];
     assert( pTerm!=0 );
     assert( pTerm->pExpr!=0 );
     assert( omitTable==0 );
     testcase( pTerm->wtFlags & TERM_VIRTUAL );
     iReleaseReg = ++pParse->nMem;
     iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg);
     if( iRowidReg!=iReleaseReg ) sqlite3ReleaseTempReg(pParse, iReleaseReg);
     addrNxt = pLevel->addrNxt;
     sqlite3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt);
     sqlite3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt); VdbeCoverage(v);
     sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addrNxt, iRowidReg);
     VdbeCoverage(v);
     sqlite3ExprCacheAffinityChange(pParse, iRowidReg, 1);
     sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
     VdbeComment((v, "pk"));

@@ -109941,10 +112286,10 @@ static Bitmask codeOneLoopStart(

       ** seek opcodes.  It depends on a particular ordering of TK_xx
       */
       const u8 aMoveOp[] = {
            /* TK_GT */  OP_SeekGt,
            /* TK_LE */  OP_SeekLe,
            /* TK_LT */  OP_SeekLt,
            /* TK_GE */  OP_SeekGe
            /* TK_GT */  OP_SeekGT,
            /* TK_LE */  OP_SeekLE,
            /* TK_LT */  OP_SeekLT,
            /* TK_GE */  OP_SeekGE
       };
       assert( TK_LE==TK_GT+1 );      /* Make sure the ordering.. */
       assert( TK_LT==TK_GT+2 );      /*  ... of the TK_xx values... */

@@ -109958,11 +112303,17 @@ static Bitmask codeOneLoopStart(

       r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp);
       sqlite3VdbeAddOp3(v, aMoveOp[pX->op-TK_GT], iCur, addrBrk, r1);
       VdbeComment((v, "pk"));
       VdbeCoverageIf(v, pX->op==TK_GT);
       VdbeCoverageIf(v, pX->op==TK_LE);
       VdbeCoverageIf(v, pX->op==TK_LT);
       VdbeCoverageIf(v, pX->op==TK_GE);
       sqlite3ExprCacheAffinityChange(pParse, r1, 1);
       sqlite3ReleaseTempReg(pParse, rTemp);
       disableTerm(pLevel, pStart);
     }else{
       sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrBrk);
       VdbeCoverageIf(v, bRev==0);
       VdbeCoverageIf(v, bRev!=0);
     }
     if( pEnd ){
       Expr *pX;

@@ -109986,10 +112337,14 @@ static Bitmask codeOneLoopStart(

     pLevel->p2 = start;
     assert( pLevel->p5==0 );
     if( testOp!=OP_Noop ){
       iRowidReg = iReleaseReg = sqlite3GetTempReg(pParse);
       iRowidReg = ++pParse->nMem;
       sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg);
       sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
       sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg);
       VdbeCoverageIf(v, testOp==OP_Le);
       VdbeCoverageIf(v, testOp==OP_Lt);
       VdbeCoverageIf(v, testOp==OP_Ge);
       VdbeCoverageIf(v, testOp==OP_Gt);
       sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL);
     }
   }else if( pLoop->wsFlags & WHERE_INDEXED ){

@@ -110029,20 +112384,19 @@ static Bitmask codeOneLoopStart(

 ,
       OP_Rewind,           /* 2: (!start_constraints && startEq &&  !bRev) */
       OP_Last,             /* 3: (!start_constraints && startEq &&   bRev) */
       OP_SeekGt,           /* 4: (start_constraints  && !startEq && !bRev) */
       OP_SeekLt,           /* 5: (start_constraints  && !startEq &&  bRev) */
       OP_SeekGe,           /* 6: (start_constraints  &&  startEq && !bRev) */
       OP_SeekLe            /* 7: (start_constraints  &&  startEq &&  bRev) */
       OP_SeekGT,           /* 4: (start_constraints  && !startEq && !bRev) */
       OP_SeekLT,           /* 5: (start_constraints  && !startEq &&  bRev) */
       OP_SeekGE,           /* 6: (start_constraints  &&  startEq && !bRev) */
       OP_SeekLE            /* 7: (start_constraints  &&  startEq &&  bRev) */
     };
     static const u8 aEndOp[] = {
       OP_Noop,             /* 0: (!end_constraints) */
       OP_IdxGE,            /* 1: (end_constraints && !bRev) */
       OP_IdxLT             /* 2: (end_constraints && bRev) */
       OP_IdxGE,            /* 0: (end_constraints && !bRev && !endEq) */
       OP_IdxGT,            /* 1: (end_constraints && !bRev &&  endEq) */
       OP_IdxLE,            /* 2: (end_constraints &&  bRev && !endEq) */
       OP_IdxLT,            /* 3: (end_constraints &&  bRev &&  endEq) */
     };
     int nEq = pLoop->u.btree.nEq;  /* Number of == or IN terms */
     int isMinQuery = 0;            /* If this is an optimized SELECT min(x).. */
     u16 nEq = pLoop->u.btree.nEq;     /* Number of == or IN terms */
     int regBase;                 /* Base register holding constraint values */
     int r1;                      /* Temp register */
     WhereTerm *pRangeStart = 0;  /* Inequality constraint at range start */
     WhereTerm *pRangeEnd = 0;    /* Inequality constraint at range end */
     int startEq;                 /* True if range start uses ==, >= or <= */

@@ -110054,10 +112408,13 @@ static Bitmask codeOneLoopStart(

     int nExtraReg = 0;           /* Number of extra registers needed */
     int op;                      /* Instruction opcode */
     char *zStartAff;             /* Affinity for start of range constraint */
     char *zEndAff;               /* Affinity for end of range constraint */
     char cEndAff = 0;            /* Affinity for end of range constraint */
     u8 bSeekPastNull = 0;        /* True to seek past initial nulls */
     u8 bStopAtNull = 0;          /* Add condition to terminate at NULLs */
     pIdx = pLoop->u.btree.pIndex;
     iIdxCur = pLevel->iIdxCur;
     assert( nEq>=pLoop->u.btree.nSkip );
     /* If this loop satisfies a sort order (pOrderBy) request that
     ** was passed to this function to implement a "SELECT min(x) ..."

@@ -110069,11 +112426,10 @@ static Bitmask codeOneLoopStart(

     */
     if( (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)!=0
      && (pWInfo->bOBSat!=0)
      && (pIdx->nColumn>nEq)
      && (pIdx->nKeyCol>nEq)
     ){
       /* assert( pOrderBy->nExpr==1 ); */
       /* assert( pOrderBy->a[0].pExpr->iColumn==pIdx->aiColumn[nEq] ); */
       isMinQuery = 1;
       assert( pLoop->u.btree.nSkip==0 );
       bSeekPastNull = 1;
       nExtraReg = 1;
     }

@@ -110088,24 +112444,33 @@ static Bitmask codeOneLoopStart(

     if( pLoop->wsFlags & WHERE_TOP_LIMIT ){
       pRangeEnd = pLoop->aLTerm[j++];
       nExtraReg = 1;
       if( pRangeStart==0
        && (j = pIdx->aiColumn[nEq])>=0
        && pIdx->pTable->aCol[j].notNull==0
       ){
         bSeekPastNull = 1;
       }
     }
     assert( pRangeEnd==0 || (pRangeEnd->wtFlags & TERM_VNULL)==0 );
     /* Generate code to evaluate all constraint terms using == or IN
     ** and store the values of those terms in an array of registers
     ** starting at regBase.
     */
     regBase = codeAllEqualityTerms(pParse,pLevel,bRev,nExtraReg,&zStartAff);
     zEndAff = sqlite3DbStrDup(db, zStartAff);
     assert( zStartAff==0 || sqlite3Strlen30(zStartAff)>=nEq );
     if( zStartAff ) cEndAff = zStartAff[nEq];
     addrNxt = pLevel->addrNxt;
     /* If we are doing a reverse order scan on an ascending index, or
     ** a forward order scan on a descending index, interchange the
     ** start and end terms (pRangeStart and pRangeEnd).
     */
     if( (nEq<pIdx->nColumn && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC))
      || (bRev && pIdx->nColumn==nEq)
     if( (nEq<pIdx->nKeyCol && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC))
      || (bRev && pIdx->nKeyCol==nEq)
     ){
       SWAP(WhereTerm *, pRangeEnd, pRangeStart);
       SWAP(u8, bSeekPastNull, bStopAtNull);
     }
     testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 );

@@ -110121,8 +112486,11 @@ static Bitmask codeOneLoopStart(

     if( pRangeStart ){
       Expr *pRight = pRangeStart->pExpr->pRight;
       sqlite3ExprCode(pParse, pRight, regBase+nEq);
       if( (pRangeStart->wtFlags & TERM_VNULL)==0 ){
         sqlite3ExprCodeIsNullJump(v, pRight, regBase+nEq, addrNxt);
       if( (pRangeStart->wtFlags & TERM_VNULL)==0
        && sqlite3ExprCanBeNull(pRight)
       ){
         sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt);
         VdbeCoverage(v);
       }
       if( zStartAff ){
         if( sqlite3CompareAffinity(pRight, zStartAff[nEq])==SQLITE_AFF_NONE){

@@ -110137,22 +112505,23 @@ static Bitmask codeOneLoopStart(

       }
       nConstraint++;
       testcase( pRangeStart->wtFlags & TERM_VIRTUAL );
     }else if( isMinQuery ){
     }else if( bSeekPastNull ){
       sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
       nConstraint++;
       startEq = 0;
       start_constraints = 1;
     }
     codeApplyAffinity(pParse, regBase, nConstraint, zStartAff);
     codeApplyAffinity(pParse, regBase, nConstraint - bSeekPastNull, zStartAff);
     op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev];
     assert( op!=0 );
     testcase( op==OP_Rewind );
     testcase( op==OP_Last );
     testcase( op==OP_SeekGt );
     testcase( op==OP_SeekGe );
     testcase( op==OP_SeekLe );
     testcase( op==OP_SeekLt );
     sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
     VdbeCoverage(v);
     VdbeCoverageIf(v, op==OP_Rewind);  testcase( op==OP_Rewind );
     VdbeCoverageIf(v, op==OP_Last);    testcase( op==OP_Last );
     VdbeCoverageIf(v, op==OP_SeekGT);  testcase( op==OP_SeekGT );
     VdbeCoverageIf(v, op==OP_SeekGE);  testcase( op==OP_SeekGE );
     VdbeCoverageIf(v, op==OP_SeekLE);  testcase( op==OP_SeekLE );
     VdbeCoverageIf(v, op==OP_SeekLT);  testcase( op==OP_SeekLT );
     /* Load the value for the inequality constraint at the end of the
     ** range (if any).

@@ -110162,61 +112531,58 @@ static Bitmask codeOneLoopStart(

       Expr *pRight = pRangeEnd->pExpr->pRight;
       sqlite3ExprCacheRemove(pParse, regBase+nEq, 1);
       sqlite3ExprCode(pParse, pRight, regBase+nEq);
       if( (pRangeEnd->wtFlags & TERM_VNULL)==0 ){
         sqlite3ExprCodeIsNullJump(v, pRight, regBase+nEq, addrNxt);
       if( (pRangeEnd->wtFlags & TERM_VNULL)==0
        && sqlite3ExprCanBeNull(pRight)
       ){
         sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt);
         VdbeCoverage(v);
       }
       if( sqlite3CompareAffinity(pRight, cEndAff)!=SQLITE_AFF_NONE
        && !sqlite3ExprNeedsNoAffinityChange(pRight, cEndAff)
       ){
         codeApplyAffinity(pParse, regBase+nEq, 1, &cEndAff);
       }
       if( zEndAff ){
         if( sqlite3CompareAffinity(pRight, zEndAff[nEq])==SQLITE_AFF_NONE){
           /* Since the comparison is to be performed with no conversions
           ** applied to the operands, set the affinity to apply to pRight to
           ** SQLITE_AFF_NONE.  */
           zEndAff[nEq] = SQLITE_AFF_NONE;
         }
         if( sqlite3ExprNeedsNoAffinityChange(pRight, zEndAff[nEq]) ){
           zEndAff[nEq] = SQLITE_AFF_NONE;
         }
       }
       codeApplyAffinity(pParse, regBase, nEq+1, zEndAff);
       nConstraint++;
       testcase( pRangeEnd->wtFlags & TERM_VIRTUAL );
     }else if( bStopAtNull ){
       sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
       endEq = 0;
       nConstraint++;
     }
     sqlite3DbFree(db, zStartAff);
     sqlite3DbFree(db, zEndAff);
     /* Top of the loop body */
     pLevel->p2 = sqlite3VdbeCurrentAddr(v);
     /* Check if the index cursor is past the end of the range. */
     op = aEndOp[(pRangeEnd || nEq) * (1 + bRev)];
     testcase( op==OP_Noop );
     testcase( op==OP_IdxGE );
     testcase( op==OP_IdxLT );
     if( op!=OP_Noop ){
     if( nConstraint ){
       op = aEndOp[bRev*2 + endEq];
       sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
       sqlite3VdbeChangeP5(v, endEq!=bRev ?1:0);
     }
     /* If there are inequality constraints, check that the value
     ** of the table column that the inequality contrains is not NULL.
     ** If it is, jump to the next iteration of the loop.
     */
     r1 = sqlite3GetTempReg(pParse);
     testcase( pLoop->wsFlags & WHERE_BTM_LIMIT );
     testcase( pLoop->wsFlags & WHERE_TOP_LIMIT );
     if( (pLoop->wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 ){
       sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, nEq, r1);
       sqlite3VdbeAddOp2(v, OP_IsNull, r1, addrCont);
       testcase( op==OP_IdxGT );  VdbeCoverageIf(v, op==OP_IdxGT );
       testcase( op==OP_IdxGE );  VdbeCoverageIf(v, op==OP_IdxGE );
       testcase( op==OP_IdxLT );  VdbeCoverageIf(v, op==OP_IdxLT );
       testcase( op==OP_IdxLE );  VdbeCoverageIf(v, op==OP_IdxLE );
     }
     sqlite3ReleaseTempReg(pParse, r1);
     /* Seek the table cursor, if required */
     disableTerm(pLevel, pRangeStart);
     disableTerm(pLevel, pRangeEnd);
     if( !omitTable ){
       iRowidReg = iReleaseReg = sqlite3GetTempReg(pParse);
     if( omitTable ){
       /* pIdx is a covering index.  No need to access the main table. */
     }else if( HasRowid(pIdx->pTable) ){
       iRowidReg = ++pParse->nMem;
       sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, iRowidReg);
       sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
       sqlite3VdbeAddOp2(v, OP_Seek, iCur, iRowidReg);  /* Deferred seek */
     }else{
       Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
       iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol);
       for(j=0; j<pPk->nKeyCol; j++){
         k = sqlite3ColumnOfIndex(pIdx, pPk->aiColumn[j]);
         sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, iRowidReg+j);
       }
       sqlite3VdbeAddOp4Int(v, OP_NotFound, iCur, addrCont,
                            iRowidReg, pPk->nKeyCol); VdbeCoverage(v);
     }
     /* Record the instruction used to terminate the loop. Disable

@@ -110230,6 +112596,8 @@ static Bitmask codeOneLoopStart(

       pLevel->op = OP_Next;
     }
     pLevel->p1 = iIdxCur;
     assert( (WHERE_UNQ_WANTED>>16)==1 );
     pLevel->p3 = (pLoop->wsFlags>>16)&1;
     if( (pLoop->wsFlags & WHERE_CONSTRAINT)==0 ){
       pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
     }else{

@@ -110360,7 +112728,9 @@ static Bitmask codeOneLoopStart(

         Expr *pExpr = pWC->a[iTerm].pExpr;
         if( &pWC->a[iTerm] == pTerm ) continue;
         if( ExprHasProperty(pExpr, EP_FromJoin) ) continue;
         if( pWC->a[iTerm].wtFlags & (TERM_ORINFO) ) continue;
         testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO );
         testcase( pWC->a[iTerm].wtFlags & TERM_VIRTUAL );
         if( pWC->a[iTerm].wtFlags & (TERM_ORINFO|TERM_VIRTUAL) ) continue;
         if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue;
         pExpr = sqlite3ExprDup(db, pExpr, 0);
         pAndExpr = sqlite3ExprAnd(db, pAndExpr, pExpr);

@@ -110396,6 +112766,7 @@ static Bitmask codeOneLoopStart(

                                          regRowid, 0);
             sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset,
                                  sqlite3VdbeCurrentAddr(v)+2, r, iSet);
             VdbeCoverage(v);
           }
           sqlite3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody);

@@ -110456,10 +112827,18 @@ static Bitmask codeOneLoopStart(

     static const u8 aStep[] = { OP_Next, OP_Prev };
     static const u8 aStart[] = { OP_Rewind, OP_Last };
     assert( bRev==0 || bRev==1 );
     pLevel->op = aStep[bRev];
     pLevel->p1 = iCur;
     pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
     pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
     if( pTabItem->isRecursive ){
       /* Tables marked isRecursive have only a single row that is stored in
       ** a pseudo-cursor.  No need to Rewind or Next such cursors. */
       pLevel->op = OP_Noop;
     }else{
       pLevel->op = aStep[bRev];
       pLevel->p1 = iCur;
       pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
       VdbeCoverageIf(v, bRev==0);
       VdbeCoverageIf(v, bRev!=0);
       pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
     }
   }
   /* Insert code to test every subexpression that can be completely

@@ -110508,7 +112887,7 @@ static Bitmask codeOneLoopStart(

     if( pAlt->wtFlags & (TERM_CODED) ) continue;
     testcase( pAlt->eOperator & WO_EQ );
     testcase( pAlt->eOperator & WO_IN );
     VdbeNoopComment((v, "begin transitive constraint"));
     VdbeModuleComment((v, "begin transitive constraint"));
     pEAlt = sqlite3StackAllocRaw(db, sizeof(*pEAlt));
     if( pEAlt ){
       *pEAlt = *pAlt->pExpr;

@@ -110539,27 +112918,42 @@ static Bitmask codeOneLoopStart(

       pTerm->wtFlags |= TERM_CODED;
     }
   }
   sqlite3ReleaseTempReg(pParse, iReleaseReg);
   return pLevel->notReady;
 }
 #if defined(WHERETRACE_ENABLED) && defined(SQLITE_ENABLE_TREE_EXPLAIN)
 /*
 ** Generate "Explanation" text for a WhereTerm.
 */
 static void whereExplainTerm(Vdbe *v, WhereTerm *pTerm){
   char zType[4];
   memcpy(zType, "...", 4);
   if( pTerm->wtFlags & TERM_VIRTUAL ) zType[0] = 'V';
   if( pTerm->eOperator & WO_EQUIV  ) zType[1] = 'E';
   if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) zType[2] = 'L';
   sqlite3ExplainPrintf(v, "%s ", zType);
   sqlite3ExplainExpr(v, pTerm->pExpr);
 }
 #endif /* WHERETRACE_ENABLED && SQLITE_ENABLE_TREE_EXPLAIN */
 #ifdef WHERETRACE_ENABLED
 /*
 ** Print a WhereLoop object for debugging purposes
 */
 static void whereLoopPrint(WhereLoop *p, SrcList *pTabList){
   int nb = 1+(pTabList->nSrc+7)/8;
   struct SrcList_item *pItem = pTabList->a + p->iTab;
 static void whereLoopPrint(WhereLoop *p, WhereClause *pWC){
   WhereInfo *pWInfo = pWC->pWInfo;
   int nb = 1+(pWInfo->pTabList->nSrc+7)/8;
   struct SrcList_item *pItem = pWInfo->pTabList->a + p->iTab;
   Table *pTab = pItem->pTab;
   sqlite3DebugPrintf("%c%2d.%0*llx.%0*llx", p->cId,
                      p->iTab, nb, p->maskSelf, nb, p->prereq);
   sqlite3DebugPrintf(" %12s",
                      pItem->zAlias ? pItem->zAlias : pTab->zName);
   if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){
     if( p->u.btree.pIndex ){
       const char *zName = p->u.btree.pIndex->zName;
       if( zName==0 ) zName = "ipk";
      const char *zName;
      if( p->u.btree.pIndex && (zName = p->u.btree.pIndex->zName)!=0 ){
       if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){
         int i = sqlite3Strlen30(zName) - 1;
         while( zName[i]!='_' ) i--;

@@ -110582,6 +112976,27 @@ static void whereLoopPrint(WhereLoop *p, SrcList *pTabList){

   }
   sqlite3DebugPrintf(" f %04x N %d", p->wsFlags, p->nLTerm);
   sqlite3DebugPrintf(" cost %d,%d,%d\n", p->rSetup, p->rRun, p->nOut);
 #ifdef SQLITE_ENABLE_TREE_EXPLAIN
   /* If the 0x100 bit of wheretracing is set, then show all of the constraint
   ** expressions in the WhereLoop.aLTerm[] array.
   */
   if( p->nLTerm && (sqlite3WhereTrace & 0x100)!=0 ){  /* WHERETRACE 0x100 */
     int i;
     Vdbe *v = pWInfo->pParse->pVdbe;
     sqlite3ExplainBegin(v);
     for(i=0; i<p->nLTerm; i++){
       WhereTerm *pTerm = p->aLTerm[i];
       if( pTerm==0 ) continue;
       sqlite3ExplainPrintf(v, "  (%d) #%-2d ", i+1, (int)(pTerm-pWC->a));
       sqlite3ExplainPush(v);
       whereExplainTerm(v, pTerm);
       sqlite3ExplainPop(v);
       sqlite3ExplainNL(v);
     }
     sqlite3ExplainFinish(v);
     sqlite3DebugPrintf("%s", sqlite3VdbeExplanation(v));
   }
 #endif
 }
 #endif

@@ -110607,6 +113022,7 @@ static void whereLoopClearUnion(sqlite3 *db, WhereLoop *p){

       p->u.vtab.idxStr = 0;
     }else if( (p->wsFlags & WHERE_AUTO_INDEX)!=0 && p->u.btree.pIndex!=0 ){
       sqlite3DbFree(db, p->u.btree.pIndex->zColAff);
       sqlite3KeyInfoUnref(p->u.btree.pIndex->pKeyInfo);
       sqlite3DbFree(db, p->u.btree.pIndex);
       p->u.btree.pIndex = 0;
     }

@@ -110721,10 +113137,10 @@ static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){

 #endif
     whereOrInsert(pBuilder->pOrSet, pTemplate->prereq, pTemplate->rRun,
                                     pTemplate->nOut);
 #if WHERETRACE_ENABLED
 #if WHERETRACE_ENABLED /* 0x8 */
     if( sqlite3WhereTrace & 0x8 ){
       sqlite3DebugPrintf(x?"   or-%d:  ":"   or-X:  ", n);
       whereLoopPrint(pTemplate, pWInfo->pTabList);
       whereLoopPrint(pTemplate, pBuilder->pWC);
     }
 #endif
     return SQLITE_OK;

@@ -110794,14 +113210,14 @@ static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){

   ** with pTemplate[] if p[] exists, or if p==NULL then allocate a new
   ** WhereLoop and insert it.
   */
 #if WHERETRACE_ENABLED
 #if WHERETRACE_ENABLED /* 0x8 */
   if( sqlite3WhereTrace & 0x8 ){
     if( p!=0 ){
       sqlite3DebugPrintf("ins-del:  ");
       whereLoopPrint(p, pWInfo->pTabList);
       whereLoopPrint(p, pBuilder->pWC);
     }
     sqlite3DebugPrintf("ins-new:  ");
     whereLoopPrint(pTemplate, pWInfo->pTabList);
     whereLoopPrint(pTemplate, pBuilder->pWC);
   }
 #endif
   if( p==0 ){

@@ -110822,10 +113238,10 @@ static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){

   /* Jump here if the insert is a no-op */
 whereLoopInsert_noop:
 #if WHERETRACE_ENABLED
 #if WHERETRACE_ENABLED /* 0x8 */
   if( sqlite3WhereTrace & 0x8 ){
     sqlite3DebugPrintf("ins-noop: ");
     whereLoopPrint(pTemplate, pWInfo->pTabList);
     whereLoopPrint(pTemplate, pBuilder->pWC);
   }
 #endif
   return SQLITE_OK;

@@ -110854,6 +113270,7 @@ static void whereLoopOutputAdjust(WhereClause *pWC, WhereLoop *pLoop){

     if( (pTerm->prereqAll & notAllowed)!=0 ) continue;
     for(j=pLoop->nLTerm-1; j>=0; j--){
       pX = pLoop->aLTerm[j];
       if( pX==0 ) continue;
       if( pX==pTerm ) break;
       if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break;
     }

@@ -110883,7 +113300,8 @@ static int whereLoopAddBtreeIndex(

   WhereScan scan;                 /* Iterator for WHERE terms */
   Bitmask saved_prereq;           /* Original value of pNew->prereq */
   u16 saved_nLTerm;               /* Original value of pNew->nLTerm */
   int saved_nEq;                  /* Original value of pNew->u.btree.nEq */
   u16 saved_nEq;                  /* Original value of pNew->u.btree.nEq */
   u16 saved_nSkip;                /* Original value of pNew->u.btree.nSkip */
   u32 saved_wsFlags;              /* Original value of pNew->wsFlags */
   LogEst saved_nOut;              /* Original value of pNew->nOut */
   int iCol;                       /* Index of the column in the table */

@@ -110906,8 +113324,8 @@ static int whereLoopAddBtreeIndex(

   }
   if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE);
   assert( pNew->u.btree.nEq<=pProbe->nColumn );
   if( pNew->u.btree.nEq < pProbe->nColumn ){
   assert( pNew->u.btree.nEq<=pProbe->nKeyCol );
   if( pNew->u.btree.nEq < pProbe->nKeyCol ){
     iCol = pProbe->aiColumn[pNew->u.btree.nEq];
     nRowEst = sqlite3LogEst(pProbe->aiRowEst[pNew->u.btree.nEq+1]);
     if( nRowEst==0 && pProbe->onError==OE_None ) nRowEst = 1;

@@ -110918,12 +113336,37 @@ static int whereLoopAddBtreeIndex(

   pTerm = whereScanInit(&scan, pBuilder->pWC, pSrc->iCursor, iCol,
                         opMask, pProbe);
   saved_nEq = pNew->u.btree.nEq;
   saved_nSkip = pNew->u.btree.nSkip;
   saved_nLTerm = pNew->nLTerm;
   saved_wsFlags = pNew->wsFlags;
   saved_prereq = pNew->prereq;
   saved_nOut = pNew->nOut;
   pNew->rSetup = 0;
   rLogSize = estLog(sqlite3LogEst(pProbe->aiRowEst[0]));
   /* Consider using a skip-scan if there are no WHERE clause constraints
   ** available for the left-most terms of the index, and if the average
   ** number of repeats in the left-most terms is at least 18.  The magic
   ** number 18 was found by experimentation to be the payoff point where
   ** skip-scan become faster than a full-scan.
   */
   if( pTerm==0
    && saved_nEq==saved_nSkip
    && saved_nEq+1<pProbe->nKeyCol
    && pProbe->aiRowEst[saved_nEq+1]>=18  /* TUNING: Minimum for skip-scan */
    && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
   ){
     LogEst nIter;
     pNew->u.btree.nEq++;
     pNew->u.btree.nSkip++;
     pNew->aLTerm[pNew->nLTerm++] = 0;
     pNew->wsFlags |= WHERE_SKIPSCAN;
     nIter = sqlite3LogEst(pProbe->aiRowEst[0]/pProbe->aiRowEst[saved_nEq+1]);
     pNew->rRun = rLogSize + nIter;
     pNew->nOut += nIter;
     whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nIter);
     pNew->nOut = saved_nOut;
   }
   for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){
     int nIn = 0;
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4

@@ -110959,15 +113402,18 @@ static int whereLoopAddBtreeIndex(

       pNew->u.btree.nEq++;
       pNew->nOut = nRowEst + nInMul + nIn;
     }else if( pTerm->eOperator & (WO_EQ) ){
       assert( (pNew->wsFlags & (WHERE_COLUMN_NULL|WHERE_COLUMN_IN))!=0
                   || nInMul==0 );
       assert(
         (pNew->wsFlags & (WHERE_COLUMN_NULL|WHERE_COLUMN_IN|WHERE_SKIPSCAN))!=0
         || nInMul==0
       );
       pNew->wsFlags |= WHERE_COLUMN_EQ;
       if( iCol<0
        || (pProbe->onError!=OE_None && nInMul==0
            && pNew->u.btree.nEq==pProbe->nColumn-1)
       ){
       if( iCol<0 || (nInMul==0 && pNew->u.btree.nEq==pProbe->nKeyCol-1)){
         assert( (pNew->wsFlags & WHERE_COLUMN_IN)==0 || iCol<0 );
         pNew->wsFlags |= WHERE_ONEROW;
         if( iCol>=0 && pProbe->onError==OE_None ){
           pNew->wsFlags |= WHERE_UNQ_WANTED;
         }else{
           pNew->wsFlags |= WHERE_ONEROW;
         }
       }
       pNew->u.btree.nEq++;
       pNew->nOut = nRowEst + nInMul;

@@ -111030,7 +113476,7 @@ static int whereLoopAddBtreeIndex(

     whereLoopOutputAdjust(pBuilder->pWC, pNew);
     rc = whereLoopInsert(pBuilder, pNew);
     if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0
      && pNew->u.btree.nEq<(pProbe->nColumn + (pProbe->zName!=0))
      && pNew->u.btree.nEq<(pProbe->nKeyCol + (pProbe->zName!=0))
     ){
       whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nInMul+nIn);
     }

@@ -111041,6 +113487,7 @@ static int whereLoopAddBtreeIndex(

   }
   pNew->prereq = saved_prereq;
   pNew->u.btree.nEq = saved_nEq;
   pNew->u.btree.nSkip = saved_nSkip;
   pNew->wsFlags = saved_wsFlags;
   pNew->nOut = saved_nOut;
   pNew->nLTerm = saved_nLTerm;

@@ -111069,7 +113516,7 @@ static int indexMightHelpWithOrderBy(

     Expr *pExpr = sqlite3ExprSkipCollate(pOB->a[ii].pExpr);
     if( pExpr->op!=TK_COLUMN ) return 0;
     if( pExpr->iTable==iCursor ){
       for(jj=0; jj<pIndex->nColumn; jj++){
       for(jj=0; jj<pIndex->nKeyCol; jj++){
         if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1;
       }
     }

@@ -111086,10 +113533,11 @@ static Bitmask columnsInIndex(Index *pIdx){

   int j;
   for(j=pIdx->nColumn-1; j>=0; j--){
     int x = pIdx->aiColumn[j];
     assert( x>=0 );
     testcase( x==BMS-1 );
     testcase( x==BMS-2 );
     if( x<BMS-1 ) m |= MASKBIT(x);
     if( x>=0 ){
       testcase( x==BMS-1 );
       testcase( x==BMS-2 );
       if( x<BMS-1 ) m |= MASKBIT(x);
     }
   }
   return m;
 }

@@ -111119,7 +113567,7 @@ static int whereLoopAddBtree(

   Index *pProbe;              /* An index we are evaluating */
   Index sPk;                  /* A fake index object for the primary key */
   tRowcnt aiRowEstPk[2];      /* The aiRowEst[] value for the sPk index */
   int aiColumnPk = -1;        /* The aColumn[] value for the sPk index */
   i16 aiColumnPk = -1;        /* The aColumn[] value for the sPk index */
   SrcList *pTabList;          /* The FROM clause */
   struct SrcList_item *pSrc;  /* The FROM clause btree term to add */
   WhereLoop *pNew;            /* Template WhereLoop object */

@@ -111142,6 +113590,8 @@ static int whereLoopAddBtree(

   if( pSrc->pIndex ){
     /* An INDEXED BY clause specifies a particular index to use */
     pProbe = pSrc->pIndex;
   }else if( !HasRowid(pTab) ){
     pProbe = pTab->pIndex;
   }else{
     /* There is no INDEXED BY clause.  Create a fake Index object in local
     ** variable sPk to represent the rowid primary key index.  Make this

@@ -111149,7 +113599,7 @@ static int whereLoopAddBtree(

     ** indices to follow */
     Index *pFirst;                  /* First of real indices on the table */
     memset(&sPk, 0, sizeof(Index));
     sPk.nColumn = 1;
     sPk.nKeyCol = 1;
     sPk.aiColumn = &aiColumnPk;
     sPk.aiRowEst = aiRowEstPk;
     sPk.onError = OE_Replace;

@@ -111174,7 +113624,9 @@ static int whereLoopAddBtree(

    && pSrc->pIndex==0
    && !pSrc->viaCoroutine
    && !pSrc->notIndexed
    && HasRowid(pTab)
    && !pSrc->isCorrelated
    && !pSrc->isRecursive
   ){
     /* Generate auto-index WhereLoops */
     WhereTerm *pTerm;

@@ -111183,6 +113635,7 @@ static int whereLoopAddBtree(

       if( pTerm->prereqRight & pNew->maskSelf ) continue;
       if( termCanDriveIndex(pTerm, pSrc, 0) ){
         pNew->u.btree.nEq = 1;
         pNew->u.btree.nSkip = 0;
         pNew->u.btree.pIndex = 0;
         pNew->nLTerm = 1;
         pNew->aLTerm[0] = pTerm;

@@ -111212,6 +113665,7 @@ static int whereLoopAddBtree(

       continue;  /* Partial index inappropriate for this query */
     }
     pNew->u.btree.nEq = 0;
     pNew->u.btree.nSkip = 0;
     pNew->nLTerm = 0;
     pNew->iSortIdx = 0;
     pNew->rSetup = 0;

@@ -111236,14 +113690,21 @@ static int whereLoopAddBtree(

       pNew->nOut = rSize;
       if( rc ) break;
     }else{
       Bitmask m = pSrc->colUsed & ~columnsInIndex(pProbe);
       pNew->wsFlags = (m==0) ? (WHERE_IDX_ONLY|WHERE_INDEXED) : WHERE_INDEXED;
       Bitmask m;
       if( pProbe->isCovering ){
         pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;
         m = 0;
       }else{
         m = pSrc->colUsed & ~columnsInIndex(pProbe);
         pNew->wsFlags = (m==0) ? (WHERE_IDX_ONLY|WHERE_INDEXED) : WHERE_INDEXED;
       }
       /* Full scan via index */
       if( b
        || !HasRowid(pTab)
        || ( m==0
          && pProbe->bUnordered==0
          && pProbe->szIdxRow<pTab->szTabRow
          && (pProbe->szIdxRow<pTab->szTabRow)
          && (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0
          && sqlite3GlobalConfig.bUseCis
          && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan)

@@ -111259,7 +113720,6 @@ static int whereLoopAddBtree(

           pNew->rRun = sqlite3LogEstAdd(rSize,rLogSize) + 1 +
                         (15*pProbe->szIdxRow)/pTab->szTabRow;
         }else{
           assert( b!=0 );
           /* TUNING: Cost of scanning a non-covering index is (N+1)*log2(N)
           ** which we will simplify to just N*log2(N) */
           pNew->rRun = rSize + rLogSize;

@@ -111291,7 +113751,8 @@ static int whereLoopAddBtree(

 ** pBuilder->pNew->iTab.  That table is guaranteed to be a virtual table.
 */
 static int whereLoopAddVirtual(
   WhereLoopBuilder *pBuilder   /* WHERE clause information */
   WhereLoopBuilder *pBuilder,  /* WHERE clause information */
   Bitmask mExtra
 ){
   WhereInfo *pWInfo;           /* WHERE analysis context */
   Parse *pParse;               /* The parsing context */

@@ -111377,10 +113838,11 @@ static int whereLoopAddVirtual(

     pIdxInfo->needToFreeIdxStr = 0;
     pIdxInfo->orderByConsumed = 0;
     pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2;
     pIdxInfo->estimatedRows = 25;
     rc = vtabBestIndex(pParse, pTab, pIdxInfo);
     if( rc ) goto whereLoopAddVtab_exit;
     pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
     pNew->prereq = 0;
     pNew->prereq = mExtra;
     mxTerm = -1;
     assert( pNew->nLSlot>=nConstraint );
     for(i=0; i<nConstraint; i++) pNew->aLTerm[i] = 0;

@@ -111436,8 +113898,7 @@ static int whereLoopAddVirtual(

                                      && pIdxInfo->orderByConsumed);
       pNew->rSetup = 0;
       pNew->rRun = sqlite3LogEstFromDouble(pIdxInfo->estimatedCost);
       /* TUNING: Every virtual table query returns 25 rows */
       pNew->nOut = 46;  assert( 46==sqlite3LogEst(25) );
       pNew->nOut = sqlite3LogEst(pIdxInfo->estimatedRows);
       whereLoopInsert(pBuilder, pNew);
       if( pNew->u.vtab.needFree ){
         sqlite3_free(pNew->u.vtab.idxStr);

@@ -111475,6 +113936,7 @@ static int whereLoopAddOr(WhereLoopBuilder *pBuilder, Bitmask mExtra){

   pNew = pBuilder->pNew;
   memset(&sSum, 0, sizeof(sSum));
   pItem = pWInfo->pTabList->a + pNew->iTab;
   if( !HasRowid(pItem->pTab) ) return SQLITE_OK;
   iCur = pItem->iCursor;
   for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){

@@ -111507,8 +113969,7 @@ static int whereLoopAddOr(WhereLoopBuilder *pBuilder, Bitmask mExtra){

         sCur.n = 0;
 #ifndef SQLITE_OMIT_VIRTUALTABLE
         if( IsVirtual(pItem->pTab) ){
           rc = whereLoopAddVirtual(&sSubBuild);
           for(i=0; i<sCur.n; i++) sCur.a[i].prereq |= mExtra;
           rc = whereLoopAddVirtual(&sSubBuild, mExtra);
         }else
 #endif
         {

@@ -111578,7 +114039,7 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){

     }
     priorJoinType = pItem->jointype;
     if( IsVirtual(pItem->pTab) ){
       rc = whereLoopAddVirtual(pBuilder);
       rc = whereLoopAddVirtual(pBuilder, mExtra);
     }else{
       rc = whereLoopAddBtree(pBuilder, mExtra);
     }

@@ -111624,7 +114085,8 @@ static int wherePathSatisfiesOrderBy(

   u8 isOrderDistinct;   /* All prior WhereLoops are order-distinct */
   u8 distinctColumns;   /* True if the loop has UNIQUE NOT NULL columns */
   u8 isMatch;           /* iColumn matches a term of the ORDER BY clause */
   u16 nColumn;          /* Number of columns in pIndex */
   u16 nKeyCol;          /* Number of key columns in pIndex */
   u16 nColumn;          /* Total number of ordered columns in the index */
   u16 nOrderBy;         /* Number terms in the ORDER BY clause */
   int iLoop;            /* Index of WhereLoop in pPath being processed */
   int i, j;             /* Loop counters */

@@ -111716,11 +114178,15 @@ static int wherePathSatisfiesOrderBy(

     if( (pLoop->wsFlags & WHERE_ONEROW)==0 ){
       if( pLoop->wsFlags & WHERE_IPK ){
         pIndex = 0;
         nColumn = 0;
         nKeyCol = 0;
         nColumn = 1;
       }else if( (pIndex = pLoop->u.btree.pIndex)==0 || pIndex->bUnordered ){
         return 0;
       }else{
         nKeyCol = pIndex->nKeyCol;
         nColumn = pIndex->nColumn;
         assert( nColumn==nKeyCol+1 || !HasRowid(pIndex->pTable) );
         assert( pIndex->aiColumn[nColumn-1]==(-1) || !HasRowid(pIndex->pTable));
         isOrderDistinct = pIndex->onError!=OE_None;
       }

@@ -111729,11 +114195,12 @@ static int wherePathSatisfiesOrderBy(

       */
       rev = revSet = 0;
       distinctColumns = 0;
       for(j=0; j<=nColumn; j++){
       for(j=0; j<nColumn; j++){
         u8 bOnce;   /* True to run the ORDER BY search loop */
         /* Skip over == and IS NULL terms */
         if( j<pLoop->u.btree.nEq
          && pLoop->u.btree.nSkip==0
          && ((i = pLoop->aLTerm[j]->eOperator) & (WO_EQ|WO_ISNULL))!=0
         ){
           if( i & WO_ISNULL ){

@@ -111746,20 +114213,17 @@ static int wherePathSatisfiesOrderBy(

         /* Get the column number in the table (iColumn) and sort order
         ** (revIdx) for the j-th column of the index.
         */
         if( j<nColumn ){
           /* Normal index columns */
         if( pIndex ){
           iColumn = pIndex->aiColumn[j];
           revIdx = pIndex->aSortOrder[j];
           if( iColumn==pIndex->pTable->iPKey ) iColumn = -1;
         }else{
           /* The ROWID column at the end */
           assert( j==nColumn );
           iColumn = -1;
           revIdx = 0;
         }
         /* An unconstrained column that might be NULL means that this
         ** WhereLoop is not well-ordered
         ** WhereLoop is not well-ordered
         */
         if( isOrderDistinct
          && iColumn>=0

@@ -111810,7 +114274,7 @@ static int wherePathSatisfiesOrderBy(

           }
         }else{
           /* No match found */
           if( j==0 || j<nColumn ){
           if( j==0 || j<nKeyCol ){
             testcase( isOrderDistinct!=0 );
             isOrderDistinct = 0;
           }

@@ -111828,9 +114292,12 @@ static int wherePathSatisfiesOrderBy(

       orderDistinctMask |= pLoop->maskSelf;
       for(i=0; i<nOrderBy; i++){
         Expr *p;
         Bitmask mTerm;
         if( MASKBIT(i) & obSat ) continue;
         p = pOrderBy->a[i].pExpr;
         if( (exprTableUsage(&pWInfo->sMaskSet, p)&~orderDistinctMask)==0 ){
         mTerm = exprTableUsage(&pWInfo->sMaskSet,p);
         if( mTerm==0 && !sqlite3ExprIsConstant(p) ) continue;
         if( (mTerm&~orderDistinctMask)==0 ){
           obSat |= MASKBIT(i);
         }
       }

@@ -111983,7 +114450,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){

         }
         if( jj>=nTo ){
           if( nTo>=mxChoice && rCost>=mxCost ){
 #ifdef WHERETRACE_ENABLED
 #ifdef WHERETRACE_ENABLED /* 0x4 */
             if( sqlite3WhereTrace&0x4 ){
               sqlite3DebugPrintf("Skip   %s cost=%-3d,%3d order=%c\n",
                   wherePathName(pFrom, iLoop, pWLoop), rCost, nOut,

@@ -112001,7 +114468,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){

             jj = mxI;
           }
           pTo = &aTo[jj];
 #ifdef WHERETRACE_ENABLED
 #ifdef WHERETRACE_ENABLED /* 0x4 */
           if( sqlite3WhereTrace&0x4 ){
             sqlite3DebugPrintf("New    %s cost=%-3d,%3d order=%c\n",
                 wherePathName(pFrom, iLoop, pWLoop), rCost, nOut,

@@ -112010,7 +114477,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){

 #endif
         }else{
           if( pTo->rCost<=rCost && pTo->nRow<=nOut ){
 #ifdef WHERETRACE_ENABLED
 #ifdef WHERETRACE_ENABLED /* 0x4 */
             if( sqlite3WhereTrace&0x4 ){
               sqlite3DebugPrintf(
                   "Skip   %s cost=%-3d,%3d order=%c",

@@ -112026,7 +114493,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){

           }
           testcase( pTo->rCost==rCost+1 );
           /* A new and better score for a previously created equivalent path */
 #ifdef WHERETRACE_ENABLED
 #ifdef WHERETRACE_ENABLED /* 0x4 */
           if( sqlite3WhereTrace&0x4 ){
             sqlite3DebugPrintf(
                 "Update %s cost=%-3d,%3d order=%c",

@@ -112062,7 +114529,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){

       }
     }
 #ifdef WHERETRACE_ENABLED
 #ifdef WHERETRACE_ENABLED  /* >=2 */
     if( sqlite3WhereTrace>=2 ){
       sqlite3DebugPrintf("---- after round %d ----\n", iLoop);
       for(ii=0, pTo=aTo; ii<nTo; ii++, pTo++){

@@ -112162,6 +114629,7 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){

   pWC = &pWInfo->sWC;
   pLoop = pBuilder->pNew;
   pLoop->wsFlags = 0;
   pLoop->u.btree.nSkip = 0;
   pTerm = findTerm(pWC, iCur, -1, 0, WO_EQ, 0);
   if( pTerm ){
     pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_IPK|WHERE_ONEROW;

@@ -112176,16 +114644,16 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){

       assert( ArraySize(pLoop->aLTermSpace)==4 );
       if( pIdx->onError==OE_None
        || pIdx->pPartIdxWhere!=0
        || pIdx->nColumn>ArraySize(pLoop->aLTermSpace)
        || pIdx->nKeyCol>ArraySize(pLoop->aLTermSpace)
       ) continue;
       for(j=0; j<pIdx->nColumn; j++){
       for(j=0; j<pIdx->nKeyCol; j++){
         pTerm = findTerm(pWC, iCur, pIdx->aiColumn[j], 0, WO_EQ, pIdx);
         if( pTerm==0 ) break;
         pLoop->aLTerm[j] = pTerm;
       }
       if( j!=pIdx->nColumn ) continue;
       if( j!=pIdx->nKeyCol ) continue;
       pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_ONEROW|WHERE_INDEXED;
       if( (pItem->colUsed & ~columnsInIndex(pIdx))==0 ){
       if( pIdx->isCovering || (pItem->colUsed & ~columnsInIndex(pIdx))==0 ){
         pLoop->wsFlags |= WHERE_IDX_ONLY;
       }
       pLoop->nLTerm = j;

@@ -112293,6 +114761,14 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){

 ** if the WHERE_GROUPBY flag is set in wctrlFlags) of a SELECT statement
 ** if there is one.  If there is no ORDER BY clause or if this routine
 ** is called from an UPDATE or DELETE statement, then pOrderBy is NULL.
 **
 ** The iIdxCur parameter is the cursor number of an index.  If
 ** WHERE_ONETABLE_ONLY is set, iIdxCur is the cursor number of an index
 ** to use for OR clause processing.  The WHERE clause should use this
 ** specific cursor.  If WHERE_ONEPASS_DESIRED is set, then iIdxCur is
 ** the first cursor in an array of cursors for all indices.  iIdxCur should
 ** be used to compute the appropriate cursor depending on which index is
 ** used.
 */
 SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   Parse *pParse,        /* The parser context */

@@ -112358,6 +114834,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

     pWInfo = 0;
     goto whereBeginError;
   }
   pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1;
   pWInfo->nLevel = nTabList;
   pWInfo->pParse = pParse;
   pWInfo->pTabList = pTabList;

@@ -112381,16 +114858,17 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

   */
   initMaskSet(pMaskSet);
   whereClauseInit(&pWInfo->sWC, pWInfo);
   sqlite3ExprCodeConstants(pParse, pWhere);
   whereSplit(&pWInfo->sWC, pWhere, TK_AND);
   sqlite3CodeVerifySchema(pParse, -1); /* Insert the cookie verifier Goto */
   /* Special case: a WHERE clause that is constant.  Evaluate the
   ** expression and either jump over all of the code or fall thru.
   */
   if( pWhere && (nTabList==0 || sqlite3ExprIsConstantNotJoin(pWhere)) ){
     sqlite3ExprIfFalse(pParse, pWhere, pWInfo->iBreak, SQLITE_JUMPIFNULL);
     pWhere = 0;
   for(ii=0; ii<sWLB.pWC->nTerm; ii++){
     if( nTabList==0 || sqlite3ExprIsConstantNotJoin(sWLB.pWC->a[ii].pExpr) ){
       sqlite3ExprIfFalse(pParse, sWLB.pWC->a[ii].pExpr, pWInfo->iBreak,
                          SQLITE_JUMPIFNULL);
       sWLB.pWC->a[ii].wtFlags |= TERM_CODED;
     }
   }
   /* Special case: No FROM clause

@@ -112442,22 +114920,6 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

     goto whereBeginError;
   }
   /* If the ORDER BY (or GROUP BY) clause contains references to general
   ** expressions, then we won't be able to satisfy it using indices, so
   ** go ahead and disable it now.
   */
   if( pOrderBy && (wctrlFlags & WHERE_WANT_DISTINCT)!=0 ){
     for(ii=0; ii<pOrderBy->nExpr; ii++){
       Expr *pExpr = sqlite3ExprSkipCollate(pOrderBy->a[ii].pExpr);
       if( pExpr->op!=TK_COLUMN ){
         pWInfo->pOrderBy = pOrderBy = 0;
         break;
       }else if( pExpr->iColumn<0 ){
         break;
       }
     }
   }
   if( wctrlFlags & WHERE_WANT_DISTINCT ){
     if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){
       /* The DISTINCT marking is pointless.  Ignore it. */

@@ -112471,12 +114933,29 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

   /* Construct the WhereLoop objects */
   WHERETRACE(0xffff,("*** Optimizer Start ***\n"));
   /* Display all terms of the WHERE clause */
 #if defined(WHERETRACE_ENABLED) && defined(SQLITE_ENABLE_TREE_EXPLAIN)
   if( sqlite3WhereTrace & 0x100 ){
     int i;
     Vdbe *v = pParse->pVdbe;
     sqlite3ExplainBegin(v);
     for(i=0; i<sWLB.pWC->nTerm; i++){
       sqlite3ExplainPrintf(v, "#%-2d ", i);
       sqlite3ExplainPush(v);
       whereExplainTerm(v, &sWLB.pWC->a[i]);
       sqlite3ExplainPop(v);
       sqlite3ExplainNL(v);
     }
     sqlite3ExplainFinish(v);
     sqlite3DebugPrintf("%s", sqlite3VdbeExplanation(v));
   }
 #endif
   if( nTabList!=1 || whereShortCut(&sWLB)==0 ){
     rc = whereLoopAddAll(&sWLB);
     if( rc ) goto whereBeginError;
     /* Display all of the WhereLoop objects if wheretrace is enabled */
 #ifdef WHERETRACE_ENABLED
 #ifdef WHERETRACE_ENABLED /* !=0 */
     if( sqlite3WhereTrace ){
       WhereLoop *p;
       int i;

@@ -112484,7 +114963,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

                                        "ABCDEFGHIJKLMNOPQRSTUVWYXZ";
       for(p=pWInfo->pLoops, i=0; p; p=p->pNextLoop, i++){
         p->cId = zLabel[i%sizeof(zLabel)];
         whereLoopPrint(p, pTabList);
         whereLoopPrint(p, sWLB.pWC);
       }
     }
 #endif

@@ -112502,7 +114981,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

   if( pParse->nErr || NEVER(db->mallocFailed) ){
     goto whereBeginError;
   }
 #ifdef WHERETRACE_ENABLED
 #ifdef WHERETRACE_ENABLED /* !=0 */
   if( sqlite3WhereTrace ){
     int ii;
     sqlite3DebugPrintf("---- Solution nRow=%d", pWInfo->nRowOut);

@@ -112525,7 +115004,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

     }
     sqlite3DebugPrintf("\n");
     for(ii=0; ii<pWInfo->nLevel; ii++){
       whereLoopPrint(pWInfo->a[ii].pWLoop, pTabList);
       whereLoopPrint(pWInfo->a[ii].pWLoop, sWLB.pWC);
     }
   }
 #endif

@@ -112572,7 +115051,9 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

   if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0
    && (pWInfo->a[0].pWLoop->wsFlags & WHERE_ONEROW)!=0 ){
     pWInfo->okOnePass = 1;
     pWInfo->a[0].pWLoop->wsFlags &= ~WHERE_IDX_ONLY;
     if( HasRowid(pTabList->a[0].pTab) ){
       pWInfo->a[0].pWLoop->wsFlags &= ~WHERE_IDX_ONLY;
     }
   }
   /* Open all tables in the pTabList and any indices selected for

@@ -112602,11 +115083,16 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

 #endif
     if( (pLoop->wsFlags & WHERE_IDX_ONLY)==0
          && (wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0 ){
       int op = pWInfo->okOnePass ? OP_OpenWrite : OP_OpenRead;
       int op = OP_OpenRead;
       if( pWInfo->okOnePass ){
         op = OP_OpenWrite;
         pWInfo->aiCurOnePass[0] = pTabItem->iCursor;
       };
       sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
       assert( pTabItem->iCursor==pLevel->iTabCur );
       testcase( !pWInfo->okOnePass && pTab->nCol==BMS-1 );
       testcase( !pWInfo->okOnePass && pTab->nCol==BMS );
       if( !pWInfo->okOnePass && pTab->nCol<BMS ){
       if( !pWInfo->okOnePass && pTab->nCol<BMS && HasRowid(pTab) ){
         Bitmask b = pTabItem->colUsed;
         int n = 0;
         for(; b; b=b>>1, n++){}

@@ -112619,16 +115105,33 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

     }
     if( pLoop->wsFlags & WHERE_INDEXED ){
       Index *pIx = pLoop->u.btree.pIndex;
       KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIx);
       /* FIXME:  As an optimization use pTabItem->iCursor if WHERE_IDX_ONLY */
       int iIndexCur = pLevel->iIdxCur = iIdxCur ? iIdxCur : pParse->nTab++;
       int iIndexCur;
       int op = OP_OpenRead;
       /* iIdxCur is always set if to a positive value if ONEPASS is possible */
       assert( iIdxCur!=0 || (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 );
       if( pWInfo->okOnePass ){
         Index *pJ = pTabItem->pTab->pIndex;
         iIndexCur = iIdxCur;
         assert( wctrlFlags & WHERE_ONEPASS_DESIRED );
         while( ALWAYS(pJ) && pJ!=pIx ){
           iIndexCur++;
           pJ = pJ->pNext;
         }
         op = OP_OpenWrite;
         pWInfo->aiCurOnePass[1] = iIndexCur;
       }else if( iIdxCur && (wctrlFlags & WHERE_ONETABLE_ONLY)!=0 ){
         iIndexCur = iIdxCur;
       }else{
         iIndexCur = pParse->nTab++;
       }
       pLevel->iIdxCur = iIndexCur;
       assert( pIx->pSchema==pTab->pSchema );
       assert( iIndexCur>=0 );
       sqlite3VdbeAddOp4(v, OP_OpenRead, iIndexCur, pIx->tnum, iDb,
                         (char*)pKey, P4_KEYINFO_HANDOFF);
       sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
       sqlite3VdbeSetP4KeyInfo(pParse, pIx);
       VdbeComment((v, "%s", pIx->zName));
     }
     sqlite3CodeVerifySchema(pParse, iDb);
     if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
     notReady &= ~getMask(&pWInfo->sMaskSet, pTabItem->iCursor);
   }
   pWInfo->iTop = sqlite3VdbeCurrentAddr(v);

@@ -112655,6 +115158,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

   }
   /* Done. */
   VdbeModuleComment((v, "Begin WHERE-core"));
   return pWInfo;
   /* Jump here if malloc fails */

@@ -112681,14 +115185,20 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){

   /* Generate loop termination code.
   */
   VdbeModuleComment((v, "End WHERE-core"));
   sqlite3ExprCacheClear(pParse);
   for(i=pWInfo->nLevel-1; i>=0; i--){
     int addr;
     pLevel = &pWInfo->a[i];
     pLoop = pLevel->pWLoop;
     sqlite3VdbeResolveLabel(v, pLevel->addrCont);
     if( pLevel->op!=OP_Noop ){
       sqlite3VdbeAddOp2(v, pLevel->op, pLevel->p1, pLevel->p2);
       sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3);
       sqlite3VdbeChangeP5(v, pLevel->p5);
       VdbeCoverage(v);
       VdbeCoverageIf(v, pLevel->op==OP_Next);
       VdbeCoverageIf(v, pLevel->op==OP_Prev);
       VdbeCoverageIf(v, pLevel->op==OP_VNext);
     }
     if( pLoop->wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){
       struct InLoop *pIn;

@@ -112697,14 +115207,22 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){

       for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){
         sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
         sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop);
         VdbeCoverage(v);
         VdbeCoverageIf(v, pIn->eEndLoopOp==OP_PrevIfOpen);
         VdbeCoverageIf(v, pIn->eEndLoopOp==OP_NextIfOpen);
         sqlite3VdbeJumpHere(v, pIn->addrInTop-1);
       }
       sqlite3DbFree(db, pLevel->u.in.aInLoop);
     }
     sqlite3VdbeResolveLabel(v, pLevel->addrBrk);
     if( pLevel->addrSkip ){
       sqlite3VdbeAddOp2(v, OP_Goto, 0, pLevel->addrSkip);
       VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
       sqlite3VdbeJumpHere(v, pLevel->addrSkip);
       sqlite3VdbeJumpHere(v, pLevel->addrSkip-2);
     }
     if( pLevel->iLeftJoin ){
       int addr;
       addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin);
       addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v);
       assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0
            || (pLoop->wsFlags & WHERE_INDEXED)!=0 );
       if( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 ){

@@ -112720,6 +115238,8 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){

       }
       sqlite3VdbeJumpHere(v, addr);
     }
     VdbeModuleComment((v, "End WHERE-loop%d: %s", i,
                      pWInfo->pTabList->a[pLevel->iFrom].pTab->zName));
   }
   /* The "break" point is here, just past the end of the outer loop.

@@ -112727,15 +115247,45 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){

   */
   sqlite3VdbeResolveLabel(v, pWInfo->iBreak);
   /* Close all of the cursors that were opened by sqlite3WhereBegin.
   */
   assert( pWInfo->nLevel<=pTabList->nSrc );
   for(i=0, pLevel=pWInfo->a; i<pWInfo->nLevel; i++, pLevel++){
     int k, last;
     VdbeOp *pOp;
     Index *pIdx = 0;
     struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom];
     Table *pTab = pTabItem->pTab;
     assert( pTab!=0 );
     pLoop = pLevel->pWLoop;
     /* For a co-routine, change all OP_Column references to the table of
     ** the co-routine into OP_SCopy of result contained in a register.
     ** OP_Rowid becomes OP_Null.
     */
     if( pTabItem->viaCoroutine && !db->mallocFailed ){
       last = sqlite3VdbeCurrentAddr(v);
       k = pLevel->addrBody;
       pOp = sqlite3VdbeGetOp(v, k);
       for(; k<last; k++, pOp++){
         if( pOp->p1!=pLevel->iTabCur ) continue;
         if( pOp->opcode==OP_Column ){
           pOp->opcode = OP_SCopy;
           pOp->p1 = pOp->p2 + pTabItem->regResult;
           pOp->p2 = pOp->p3;
           pOp->p3 = 0;
         }else if( pOp->opcode==OP_Rowid ){
           pOp->opcode = OP_Null;
           pOp->p1 = 0;
           pOp->p3 = 0;
         }
       }
       continue;
     }
     /* Close all of the cursors that were opened by sqlite3WhereBegin.
     ** Except, do not close cursors that will be reused by the OR optimization
     ** (WHERE_OMIT_OPEN_CLOSE).  And do not close the OP_OpenWrite cursors
     ** created for the ONEPASS optimization.
     */
     if( (pTab->tabFlags & TF_Ephemeral)==0
      && pTab->pSelect==0
      && (pWInfo->wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0

@@ -112744,7 +115294,10 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){

       if( !pWInfo->okOnePass && (ws & WHERE_IDX_ONLY)==0 ){
         sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
       }
       if( (ws & WHERE_INDEXED)!=0 && (ws & (WHERE_IPK|WHERE_AUTO_INDEX))==0 ){
       if( (ws & WHERE_INDEXED)!=0
        && (ws & (WHERE_IPK|WHERE_AUTO_INDEX))==0
        && pLevel->iIdxCur!=pWInfo->aiCurOnePass[1]
       ){
         sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
       }
     }

@@ -112766,23 +115319,24 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){

       pIdx = pLevel->u.pCovidx;
     }
     if( pIdx && !db->mallocFailed ){
       int k, j, last;
       VdbeOp *pOp;
       last = sqlite3VdbeCurrentAddr(v);
       k = pLevel->addrBody;
       pOp = sqlite3VdbeGetOp(v, k);
       for(; k<last; k++, pOp++){
         if( pOp->p1!=pLevel->iTabCur ) continue;
         if( pOp->opcode==OP_Column ){
           for(j=0; j<pIdx->nColumn; j++){
             if( pOp->p2==pIdx->aiColumn[j] ){
               pOp->p2 = j;
               pOp->p1 = pLevel->iIdxCur;
               break;
             }
           int x = pOp->p2;
           assert( pIdx->pTable==pTab );
           if( !HasRowid(pTab) ){
             Index *pPk = sqlite3PrimaryKeyIndex(pTab);
             x = pPk->aiColumn[x];
           }
           x = sqlite3ColumnOfIndex(pIdx, x);
           if( x>=0 ){
             pOp->p2 = x;
             pOp->p1 = pLevel->iIdxCur;
           }
           assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || j<pIdx->nColumn );
           assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0 );
         }else if( pOp->opcode==OP_Rowid ){
           pOp->p1 = pLevel->iIdxCur;
           pOp->opcode = OP_IdxRowid;

@@ -112859,14 +115413,6 @@ struct TrigEvent { int a; IdList * b; };

 */
 struct AttachKey { int type;  Token key; };
 /*
 ** One or more VALUES claues
 */
 struct ValueList {
   ExprList *pList;
   Select *pSelect;
 };
   /* This is a utility routine used to set the ExprSpan.zStart and
   ** ExprSpan.zEnd values of pOut so that the span covers the complete

@@ -112990,28 +115536,28 @@ struct ValueList {

 **                       defined, then do no error processing.
 */
 #define YYCODETYPE unsigned char
 #define YYNOCODE 251
 #define YYNOCODE 254
 #define YYACTIONTYPE unsigned short int
 #define YYWILDCARD 67
 #define YYWILDCARD 70
 #define sqlite3ParserTOKENTYPE Token
 typedef union {
   int yyinit;
   sqlite3ParserTOKENTYPE yy0;
   struct LimitVal yy64;
   Expr* yy122;
   Select* yy159;
   IdList* yy180;
   struct {int value; int mask;} yy207;
   u8 yy258;
   u16 yy305;
   struct LikeOp yy318;
   TriggerStep* yy327;
   ExprSpan yy342;
   SrcList* yy347;
   int yy392;
   struct TrigEvent yy410;
   ExprList* yy442;
   struct ValueList yy487;
   Select* yy3;
   ExprList* yy14;
   With* yy59;
   SrcList* yy65;
   struct LikeOp yy96;
   Expr* yy132;
   u8 yy186;
   int yy328;
   ExprSpan yy346;
   struct TrigEvent yy378;
   u16 yy381;
   IdList* yy408;
   struct {int value; int mask;} yy429;
   TriggerStep* yy473;
   struct LimitVal yy476;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100

@@ -113020,7 +115566,7 @@ typedef union {

 #define sqlite3ParserARG_PDECL ,Parse *pParse
 #define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
 #define sqlite3ParserARG_STORE yypParser->pParse = pParse
 #define YYNSTATE 628
 #define YYNSTATE 642
 #define YYNRULE 327
 #define YYFALLBACK 1
 #define YY_NO_ACTION      (YYNSTATE+YYNRULE+2)

@@ -113091,474 +115637,463 @@ static const YYMINORTYPE yyzerominor = { 0 };

 **                     shifting non-terminals after a reduce.
 **  yy_default[]       Default action for each state.
 */
 #define YY_ACTTAB_COUNT (1564)
 #define YY_ACTTAB_COUNT (1497)
 static const YYACTIONTYPE yy_action[] = {
  /*     0 */   310,  956,  184,  418,    2,  171,  625,  595,   56,   56,
  /*    10 */    56,   56,   49,   54,   54,   54,   54,   53,   53,   52,
  /*    20 */    52,   52,   51,  233,  621,  620,  299,  621,  620,  234,
  /*    30 */   588,  582,   56,   56,   56,   56,   19,   54,   54,   54,
  /*    40 */    54,   53,   53,   52,   52,   52,   51,  233,  606,   57,
  /*    50 */    58,   48,  580,  579,  581,  581,   55,   55,   56,   56,
  /*    60 */    56,   56,  542,   54,   54,   54,   54,   53,   53,   52,
  /*    70 */    52,   52,   51,  233,  310,  595,  326,  196,  195,  194,
  /*    80 */    33,   54,   54,   54,   54,   53,   53,   52,   52,   52,
  /*    90 */    51,  233,  618,  617,  165,  618,  617,  381,  378,  377,
  /*   100 */   408,  533,  577,  577,  588,  582,  304,  423,  376,   59,
  /*   110 */    53,   53,   52,   52,   52,   51,  233,   50,   47,  146,
  /*   120 */   575,  546,   65,   57,   58,   48,  580,  579,  581,  581,
  /*   130 */    55,   55,   56,   56,   56,   56,  213,   54,   54,   54,
  /*   140 */    54,   53,   53,   52,   52,   52,   51,  233,  310,  223,
  /*   150 */   540,  421,  170,  176,  138,  281,  384,  276,  383,  168,
  /*   160 */   490,  552,  410,  669,  621,  620,  272,  439,  410,  439,
  /*   170 */   551,  605,   67,  483,  508,  619,  600,  413,  588,  582,
  /*   180 */   601,  484,  619,  413,  619,  599,   91,  440,  441,  440,
  /*   190 */   336,  599,   73,  670,  222,  267,  481,   57,   58,   48,
  /*   200 */   580,  579,  581,  581,   55,   55,   56,   56,   56,   56,
  /*   210 */   671,   54,   54,   54,   54,   53,   53,   52,   52,   52,
  /*   220 */    51,  233,  310,  280,  232,  231,    1,  132,  200,  386,
  /*   230 */   621,  620,  618,  617,  279,  436,  290,  564,  175,  263,
  /*   240 */   410,  265,  438,  498,  437,  166,  442,  569,  337,  569,
  /*   250 */   201,  538,  588,  582,  600,  413,  165,  595,  601,  381,
  /*   260 */   378,  377,  598,  599,   92,  524,  619,  570,  570,  593,
  /*   270 */   376,   57,   58,   48,  580,  579,  581,  581,   55,   55,
  /*   280 */    56,   56,   56,   56,  598,   54,   54,   54,   54,   53,
  /*   290 */    53,   52,   52,   52,   51,  233,  310,  464,  618,  617,
  /*   300 */   591,  591,  591,  174,  273,  397,  410,  273,  410,  549,
  /*   310 */   398,  621,  620,   68,  327,  621,  620,  621,  620,  619,
  /*   320 */   547,  413,  619,  413,  472,  595,  588,  582,  473,  599,
  /*   330 */    92,  599,   92,   52,   52,   52,   51,  233,  514,  513,
  /*   340 */   206,  323,  364,  465,  221,   57,   58,   48,  580,  579,
  /*   350 */   581,  581,   55,   55,   56,   56,   56,   56,  530,   54,
  /*   360 */    54,   54,   54,   53,   53,   52,   52,   52,   51,  233,
  /*   370 */   310,  397,  410,  397,  598,  373,  387,  531,  348,  618,
  /*   380 */   617,  576,  202,  618,  617,  618,  617,  413,  621,  620,
  /*   390 */   145,  255,  347,  254,  578,  599,   74,  352,   45,  490,
  /*   400 */   588,  582,  235,  189,  465,  545,  167,  297,  187,  470,
  /*   410 */   480,   67,   62,   39,  619,  547,  598,  346,  574,   57,
  /*   420 */    58,   48,  580,  579,  581,  581,   55,   55,   56,   56,
  /*   430 */    56,   56,    6,   54,   54,   54,   54,   53,   53,   52,
  /*   440 */    52,   52,   51,  233,  310,  563,  559,  408,  529,  577,
  /*   450 */   577,  345,  255,  347,  254,  182,  618,  617,  504,  505,
  /*   460 */   315,  410,  558,  235,  166,  272,  410,  353,  565,  181,
  /*   470 */   408,  547,  577,  577,  588,  582,  413,  538,  557,  562,
  /*   480 */   518,  413,  619,  249,  599,   16,    7,   36,  468,  599,
  /*   490 */    92,  517,  619,   57,   58,   48,  580,  579,  581,  581,
  /*   500 */    55,   55,   56,   56,   56,   56,  542,   54,   54,   54,
  /*   510 */    54,   53,   53,   52,   52,   52,   51,  233,  310,  328,
  /*   520 */   573,  572,  526,  559,  561,  395,  872,  246,  410,  248,
  /*   530 */   171,  393,  595,  219,  408,  410,  577,  577,  503,  558,
  /*   540 */   365,  145,  511,  413,  408,  229,  577,  577,  588,  582,
  /*   550 */   413,  599,   92,  382,  270,  557,  166,  401,  599,   69,
  /*   560 */   502,  420,  946,  199,  946,  198,  547,   57,   58,   48,
  /*   570 */   580,  579,  581,  581,   55,   55,   56,   56,   56,   56,
  /*   580 */   569,   54,   54,   54,   54,   53,   53,   52,   52,   52,
  /*   590 */    51,  233,  310,  318,  420,  945,  509,  945,  309,  598,
  /*   600 */   595,  566,  491,  212,  173,  247,  424,  616,  615,  614,
  /*   610 */   324,  197,  143,  406,  573,  572,  490,   66,   50,   47,
  /*   620 */   146,  595,  588,  582,  232,  231,  560,  428,   67,  556,
  /*   630 */    15,  619,  186,  544,  304,  422,   35,  206,  433,  424,
  /*   640 */   553,   57,   58,   48,  580,  579,  581,  581,   55,   55,
  /*   650 */    56,   56,   56,   56,  205,   54,   54,   54,   54,   53,
  /*   660 */    53,   52,   52,   52,   51,  233,  310,  570,  570,  261,
  /*   670 */   269,  598,   12,  374,  569,  166,  410,  314,  410,  421,
  /*   680 */   410,  474,  474,  366,  619,   50,   47,  146,  598,  595,
  /*   690 */   256,  413,  166,  413,  352,  413,  588,  582,   32,  599,
  /*   700 */    94,  599,   97,  599,   95,  628,  626,  330,  142,   50,
  /*   710 */    47,  146,  334,  350,  359,   57,   58,   48,  580,  579,
  /*   720 */   581,  581,   55,   55,   56,   56,   56,   56,  410,   54,
  /*   730 */    54,   54,   54,   53,   53,   52,   52,   52,   51,  233,
  /*   740 */   310,  410,  389,  413,  410,   22,  566,  405,  212,  363,
  /*   750 */   390,  599,  104,  360,  410,  156,  413,  410,  604,  413,
  /*   760 */   538,  332,  570,  570,  599,  103,  494,  599,  105,  413,
  /*   770 */   588,  582,  413,  261,  550,  619,   11,  599,  106,  522,
  /*   780 */   599,  133,  169,  458,  457,  170,   35,  602,  619,   57,
  /*   790 */    58,   48,  580,  579,  581,  581,   55,   55,   56,   56,
  /*   800 */    56,   56,  410,   54,   54,   54,   54,   53,   53,   52,
  /*   810 */    52,   52,   51,  233,  310,  410,  260,  413,  410,   50,
  /*   820 */    47,  146,  358,  319,  356,  599,  134,  528,  353,  338,
  /*   830 */   413,  410,  357,  413,  358,  410,  358,  619,  599,   98,
  /*   840 */   129,  599,  102,  619,  588,  582,  413,   21,  235,  619,
  /*   850 */   413,  619,  211,  143,  599,  101,   30,  167,  599,   93,
  /*   860 */   351,  536,  203,   57,   58,   48,  580,  579,  581,  581,
  /*   870 */    55,   55,   56,   56,   56,   56,  410,   54,   54,   54,
  /*   880 */    54,   53,   53,   52,   52,   52,   51,  233,  310,  410,
  /*   890 */   527,  413,  410,  426,  215,  306,  598,  552,  141,  599,
  /*   900 */   100,   40,  410,   38,  413,  410,  551,  413,  410,  228,
  /*   910 */   220,  315,  599,   77,  501,  599,   96,  413,  588,  582,
  /*   920 */   413,  339,  253,  413,  218,  599,  137,  380,  599,  136,
  /*   930 */    28,  599,  135,  271,  716,  210,  482,   57,   58,   48,
  /*   940 */   580,  579,  581,  581,   55,   55,   56,   56,   56,   56,
  /*   950 */   410,   54,   54,   54,   54,   53,   53,   52,   52,   52,
  /*   960 */    51,  233,  310,  410,  273,  413,  410,  316,  147,  598,
  /*   970 */   273,  627,    2,  599,   76,  209,  410,  127,  413,  619,
  /*   980 */   126,  413,  410,  622,  235,  619,  599,   90,  375,  599,
  /*   990 */    89,  413,  588,  582,   27,  261,  351,  413,  619,  599,
  /*  1000 */    75,  322,  542,  542,  125,  599,   88,  321,  279,  598,
  /*  1010 */   619,   57,   46,   48,  580,  579,  581,  581,   55,   55,
  /*  1020 */    56,   56,   56,   56,  410,   54,   54,   54,   54,   53,
  /*  1030 */    53,   52,   52,   52,   51,  233,  310,  410,  451,  413,
  /*  1040 */   164,  285,  283,  273,  610,  425,  305,  599,   87,  371,
  /*  1050 */   410,  478,  413,  410,  609,  410,  608,  603,  619,  619,
  /*  1060 */   599,   99,  587,  586,  122,  413,  588,  582,  413,  619,
  /*  1070 */   413,  619,  619,  599,   86,  367,  599,   17,  599,   85,
  /*  1080 */   320,  185,  520,  519,  584,  583,   58,   48,  580,  579,
  /*  1090 */   581,  581,   55,   55,   56,   56,   56,   56,  410,   54,
  /*  1100 */    54,   54,   54,   53,   53,   52,   52,   52,   51,  233,
  /*  1110 */   310,  585,  410,  413,  410,  261,  261,  261,  409,  592,
  /*  1120 */   475,  599,   84,  170,  410,  467,  519,  413,  121,  413,
  /*  1130 */   619,  619,  619,  619,  619,  599,   83,  599,   72,  413,
  /*  1140 */   588,  582,   51,  233,  626,  330,  471,  599,   71,  258,
  /*  1150 */   159,  120,   14,  463,  157,  158,  117,  261,  449,  448,
  /*  1160 */   447,   48,  580,  579,  581,  581,   55,   55,   56,   56,
  /*  1170 */    56,   56,  619,   54,   54,   54,   54,   53,   53,   52,
  /*  1180 */    52,   52,   51,  233,   44,  404,  261,    3,  410,  460,
  /*  1190 */   261,  414,  620,  118,  399,   10,   25,   24,  555,  349,
  /*  1200 */   217,  619,  407,  413,  410,  619,    4,   44,  404,  619,
  /*  1210 */     3,  599,   82,  619,  414,  620,  456,  543,  115,  413,
  /*  1220 */   539,  402,  537,  275,  507,  407,  251,  599,   81,  216,
  /*  1230 */   274,  564,  619,  243,  454,  619,  154,  619,  619,  619,
  /*  1240 */   450,  417,  624,  110,  402,  619,  410,  236,   64,  123,
  /*  1250 */   488,   41,   42,  532,  564,  204,  410,  268,   43,  412,
  /*  1260 */   411,  413,  266,  593,  108,  619,  107,  435,  333,  599,
  /*  1270 */    80,  413,  619,  264,   41,   42,  444,  619,  410,  599,
  /*  1280 */    70,   43,  412,  411,  434,  262,  593,  149,  619,  598,
  /*  1290 */   257,  237,  188,  413,  591,  591,  591,  590,  589,   13,
  /*  1300 */   619,  599,   18,  329,  235,  619,   44,  404,  361,    3,
  /*  1310 */   419,  462,  340,  414,  620,  227,  124,  591,  591,  591,
  /*  1320 */   590,  589,   13,  619,  407,  410,  619,  410,  139,   34,
  /*  1330 */   404,  388,    3,  148,  623,  313,  414,  620,  312,  331,
  /*  1340 */   413,  461,  413,  402,  180,  354,  413,  407,  599,   79,
  /*  1350 */   599,   78,  250,  564,  599,    9,  619,  613,  612,  611,
  /*  1360 */   619,    8,  453,  443,  242,  416,  402,  619,  239,  235,
  /*  1370 */   179,  238,  429,   41,   42,  289,  564,  619,  619,  619,
  /*  1380 */    43,  412,  411,  619,  144,  593,  619,  619,  177,   61,
  /*  1390 */   619,  597,  392,  621,  620,  288,   41,   42,  415,  619,
  /*  1400 */   294,   30,  394,   43,  412,  411,  293,  619,  593,   31,
  /*  1410 */   619,  396,  292,   60,  230,   37,  591,  591,  591,  590,
  /*  1420 */   589,   13,  214,  554,  183,  291,  172,  302,  301,  300,
  /*  1430 */   178,  298,  596,  564,  452,   29,  286,  391,  541,  591,
  /*  1440 */   591,  591,  590,  589,   13,  284,  521,  535,  150,  534,
  /*  1450 */   241,  282,  385,  192,  191,  325,  516,  515,  277,  240,
  /*  1460 */   511,  524,  308,  512,  128,  593,  510,  225,  226,  487,
  /*  1470 */   486,  224,  152,  492,  465,  307,  485,  163,  153,  372,
  /*  1480 */   479,  151,  162,  259,  370,  161,  368,  208,  476,  477,
  /*  1490 */    26,  160,  469,  466,  362,  140,  591,  591,  591,  116,
  /*  1500 */   119,  455,  344,  155,  114,  343,  113,  112,  446,  111,
  /*  1510 */   131,  109,  432,  317,  130,  431,   23,   20,  430,  427,
  /*  1520 */   190,   63,  255,  342,  244,  607,  295,  287,  311,  594,
  /*  1530 */   278,  508,  496,  235,  493,  571,  497,  568,  495,  403,
  /*  1540 */   459,  379,  355,  245,  193,  303,  567,  296,  341,    5,
  /*  1550 */   445,  548,  506,  207,  525,  500,  335,  489,  252,  369,
  /*  1560 */   400,  499,  523,  233,
  /*     0 */   306,  212,  432,  955,  639,  191,  955,  295,  559,   88,
  /*    10 */    88,   88,   88,   81,   86,   86,   86,   86,   85,   85,
  /*    20 */    84,   84,   84,   83,  330,  185,  184,  183,  635,  635,
  /*    30 */   292,  606,  606,   88,   88,   88,   88,  683,   86,   86,
  /*    40 */    86,   86,   85,   85,   84,   84,   84,   83,  330,   16,
  /*    50 */   436,  597,   89,   90,   80,  600,  599,  601,  601,   87,
  /*    60 */    87,   88,   88,   88,   88,  684,   86,   86,   86,   86,
  /*    70 */    85,   85,   84,   84,   84,   83,  330,  306,  559,   84,
  /*    80 */    84,   84,   83,  330,   65,   86,   86,   86,   86,   85,
  /*    90 */    85,   84,   84,   84,   83,  330,  635,  635,  634,  633,
  /*   100 */   182,  682,  550,  379,  376,  375,   17,  322,  606,  606,
  /*   110 */   371,  198,  479,   91,  374,   82,   79,  165,   85,   85,
  /*   120 */    84,   84,   84,   83,  330,  598,  635,  635,  107,   89,
  /*   130 */    90,   80,  600,  599,  601,  601,   87,   87,   88,   88,
  /*   140 */    88,   88,  186,   86,   86,   86,   86,   85,   85,   84,
  /*   150 */    84,   84,   83,  330,  306,  594,  594,  142,  328,  327,
  /*   160 */   484,  249,  344,  238,  635,  635,  634,  633,  585,  448,
  /*   170 */   526,  525,  229,  388,    1,  394,  450,  584,  449,  635,
  /*   180 */   635,  635,  635,  319,  395,  606,  606,  199,  157,  273,
  /*   190 */   382,  268,  381,  187,  635,  635,  634,  633,  311,  555,
  /*   200 */   266,  593,  593,  266,  347,  588,   89,   90,   80,  600,
  /*   210 */   599,  601,  601,   87,   87,   88,   88,   88,   88,  478,
  /*   220 */    86,   86,   86,   86,   85,   85,   84,   84,   84,   83,
  /*   230 */   330,  306,  272,  536,  634,  633,  146,  610,  197,  310,
  /*   240 */   575,  182,  482,  271,  379,  376,  375,  506,   21,  634,
  /*   250 */   633,  634,  633,  635,  635,  374,  611,  574,  548,  440,
  /*   260 */   111,  563,  606,  606,  634,  633,  324,  479,  608,  608,
  /*   270 */   608,  300,  435,  573,  119,  407,  210,  162,  562,  883,
  /*   280 */   592,  592,  306,   89,   90,   80,  600,  599,  601,  601,
  /*   290 */    87,   87,   88,   88,   88,   88,  506,   86,   86,   86,
  /*   300 */    86,   85,   85,   84,   84,   84,   83,  330,  620,  111,
  /*   310 */   635,  635,  361,  606,  606,  358,  249,  349,  248,  433,
  /*   320 */   243,  479,  586,  634,  633,  195,  611,   93,  119,  221,
  /*   330 */   575,  497,  534,  534,   89,   90,   80,  600,  599,  601,
  /*   340 */   601,   87,   87,   88,   88,   88,   88,  574,   86,   86,
  /*   350 */    86,   86,   85,   85,   84,   84,   84,   83,  330,  306,
  /*   360 */    77,  429,  638,  573,  589,  530,  240,  230,  242,  105,
  /*   370 */   249,  349,  248,  515,  588,  208,  460,  529,  564,  173,
  /*   380 */   634,  633,  970,  144,  430,    2,  424,  228,  380,  557,
  /*   390 */   606,  606,  190,  153,  159,  158,  514,   51,  632,  631,
  /*   400 */   630,   71,  536,  432,  954,  196,  610,  954,  614,   45,
  /*   410 */    18,   89,   90,   80,  600,  599,  601,  601,   87,   87,
  /*   420 */    88,   88,   88,   88,  261,   86,   86,   86,   86,   85,
  /*   430 */    85,   84,   84,   84,   83,  330,  306,  608,  608,  608,
  /*   440 */   542,  424,  402,  385,  241,  506,  451,  320,  211,  543,
  /*   450 */   164,  436,  386,  293,  451,  587,  108,  496,  111,  334,
  /*   460 */   391,  591,  424,  614,   27,  452,  453,  606,  606,   72,
  /*   470 */   257,   70,  259,  452,  339,  342,  564,  582,   68,  415,
  /*   480 */   469,  328,  327,   62,  614,   45,  110,  393,   89,   90,
  /*   490 */    80,  600,  599,  601,  601,   87,   87,   88,   88,   88,
  /*   500 */    88,  152,   86,   86,   86,   86,   85,   85,   84,   84,
  /*   510 */    84,   83,  330,  306,  110,  499,  520,  538,  402,  389,
  /*   520 */   424,  110,  566,  500,  593,  593,  454,   82,   79,  165,
  /*   530 */   424,  591,  384,  564,  340,  615,  188,  162,  424,  350,
  /*   540 */   616,  424,  614,   44,  606,  606,  445,  582,  300,  434,
  /*   550 */   151,   19,  614,    9,  568,  580,  348,  615,  469,  567,
  /*   560 */   614,   26,  616,  614,   45,   89,   90,   80,  600,  599,
  /*   570 */   601,  601,   87,   87,   88,   88,   88,   88,  411,   86,
  /*   580 */    86,   86,   86,   85,   85,   84,   84,   84,   83,  330,
  /*   590 */   306,  579,  110,  578,  521,  282,  433,  398,  400,  255,
  /*   600 */   486,   82,   79,  165,  487,  164,   82,   79,  165,  488,
  /*   610 */   488,  364,  387,  424,  544,  544,  509,  350,  362,  155,
  /*   620 */   191,  606,  606,  559,  642,  640,  333,   82,   79,  165,
  /*   630 */   305,  564,  507,  312,  357,  614,   45,  329,  596,  595,
  /*   640 */   194,  337,   89,   90,   80,  600,  599,  601,  601,   87,
  /*   650 */    87,   88,   88,   88,   88,  424,   86,   86,   86,   86,
  /*   660 */    85,   85,   84,   84,   84,   83,  330,  306,   20,  323,
  /*   670 */   150,  263,  211,  543,  421,  596,  595,  614,   22,  424,
  /*   680 */   193,  424,  284,  424,  391,  424,  509,  424,  577,  424,
  /*   690 */   186,  335,  424,  559,  424,  313,  120,  546,  606,  606,
  /*   700 */    67,  614,   47,  614,   50,  614,   48,  614,  100,  614,
  /*   710 */    99,  614,  101,  576,  614,  102,  614,  109,  326,   89,
  /*   720 */    90,   80,  600,  599,  601,  601,   87,   87,   88,   88,
  /*   730 */    88,   88,  424,   86,   86,   86,   86,   85,   85,   84,
  /*   740 */    84,   84,   83,  330,  306,  424,  311,  424,  585,   54,
  /*   750 */   424,  516,  517,  590,  614,  112,  424,  584,  424,  572,
  /*   760 */   424,  195,  424,  571,  424,   67,  424,  614,   94,  614,
  /*   770 */    98,  424,  614,   97,  264,  606,  606,  195,  614,   46,
  /*   780 */   614,   96,  614,   30,  614,   49,  614,  115,  614,  114,
  /*   790 */   418,  229,  388,  614,  113,  306,   89,   90,   80,  600,
  /*   800 */   599,  601,  601,   87,   87,   88,   88,   88,   88,  424,
  /*   810 */    86,   86,   86,   86,   85,   85,   84,   84,   84,   83,
  /*   820 */   330,  119,  424,  590,  110,  372,  606,  606,  195,   53,
  /*   830 */   250,  614,   29,  195,  472,  438,  729,  190,  302,  498,
  /*   840 */    14,  523,  641,    2,  614,   43,  306,   89,   90,   80,
  /*   850 */   600,  599,  601,  601,   87,   87,   88,   88,   88,   88,
  /*   860 */   424,   86,   86,   86,   86,   85,   85,   84,   84,   84,
  /*   870 */    83,  330,  424,  613,  964,  964,  354,  606,  606,  420,
  /*   880 */   312,   64,  614,   42,  391,  355,  283,  437,  301,  255,
  /*   890 */   414,  410,  495,  492,  614,   28,  471,  306,   89,   90,
  /*   900 */    80,  600,  599,  601,  601,   87,   87,   88,   88,   88,
  /*   910 */    88,  424,   86,   86,   86,   86,   85,   85,   84,   84,
  /*   920 */    84,   83,  330,  424,  110,  110,  110,  110,  606,  606,
  /*   930 */   110,  254,   13,  614,   41,  532,  531,  283,  481,  531,
  /*   940 */   457,  284,  119,  561,  356,  614,   40,  284,  306,   89,
  /*   950 */    78,   80,  600,  599,  601,  601,   87,   87,   88,   88,
  /*   960 */    88,   88,  424,   86,   86,   86,   86,   85,   85,   84,
  /*   970 */    84,   84,   83,  330,  110,  424,  341,  220,  555,  606,
  /*   980 */   606,  351,  555,  318,  614,   95,  413,  255,   83,  330,
  /*   990 */   284,  284,  255,  640,  333,  356,  255,  614,   39,  306,
  /*  1000 */   356,   90,   80,  600,  599,  601,  601,   87,   87,   88,
  /*  1010 */    88,   88,   88,  424,   86,   86,   86,   86,   85,   85,
  /*  1020 */    84,   84,   84,   83,  330,  424,  317,  316,  141,  465,
  /*  1030 */   606,  606,  219,  619,  463,  614,   10,  417,  462,  255,
  /*  1040 */   189,  510,  553,  351,  207,  363,  161,  614,   38,  315,
  /*  1050 */   218,  255,  255,   80,  600,  599,  601,  601,   87,   87,
  /*  1060 */    88,   88,   88,   88,  424,   86,   86,   86,   86,   85,
  /*  1070 */    85,   84,   84,   84,   83,  330,   76,  419,  255,    3,
  /*  1080 */   878,  461,  424,  247,  331,  331,  614,   37,  217,   76,
  /*  1090 */   419,  390,    3,  216,  215,  422,    4,  331,  331,  424,
  /*  1100 */   547,   12,  424,  545,  614,   36,  424,  541,  422,  424,
  /*  1110 */   540,  424,  214,  424,  408,  424,  539,  403,  605,  605,
  /*  1120 */   237,  614,   25,  119,  614,   24,  588,  408,  614,   45,
  /*  1130 */   118,  614,   35,  614,   34,  614,   33,  614,   23,  588,
  /*  1140 */    60,  223,  603,  602,  513,  378,   73,   74,  140,  139,
  /*  1150 */   424,  110,  265,   75,  426,  425,   59,  424,  610,   73,
  /*  1160 */    74,  549,  402,  404,  424,  373,   75,  426,  425,  604,
  /*  1170 */   138,  610,  614,   11,  392,   76,  419,  181,    3,  614,
  /*  1180 */    32,  271,  369,  331,  331,  493,  614,   31,  149,  608,
  /*  1190 */   608,  608,  607,   15,  422,  365,  614,    8,  137,  489,
  /*  1200 */   136,  190,  608,  608,  608,  607,   15,  485,  176,  135,
  /*  1210 */     7,  252,  477,  408,  174,  133,  175,  474,   57,   56,
  /*  1220 */   132,  130,  119,   76,  419,  588,    3,  468,  245,  464,
  /*  1230 */   171,  331,  331,  125,  123,  456,  447,  122,  446,  104,
  /*  1240 */   336,  231,  422,  166,  154,   73,   74,  332,  116,  431,
  /*  1250 */   121,  309,   75,  426,  425,  222,  106,  610,  308,  637,
  /*  1260 */   204,  408,  629,  627,  628,    6,  200,  428,  427,  290,
  /*  1270 */   203,  622,  201,  588,   62,   63,  289,   66,  419,  399,
  /*  1280 */     3,  401,  288,   92,  143,  331,  331,  287,  608,  608,
  /*  1290 */   608,  607,   15,   73,   74,  227,  422,  325,   69,  416,
  /*  1300 */    75,  426,  425,  612,  412,  610,  192,   61,  569,  209,
  /*  1310 */   396,  226,  278,  225,  383,  408,  527,  558,  276,  533,
  /*  1320 */   552,  528,  321,  523,  370,  508,  180,  588,  494,  179,
  /*  1330 */   366,  117,  253,  269,  522,  503,  608,  608,  608,  607,
  /*  1340 */    15,  551,  502,   58,  274,  524,  178,   73,   74,  304,
  /*  1350 */   501,  368,  303,  206,   75,  426,  425,  491,  360,  610,
  /*  1360 */   213,  177,  483,  131,  345,  298,  297,  296,  202,  294,
  /*  1370 */   480,  490,  466,  134,  172,  129,  444,  346,  470,  128,
  /*  1380 */   314,  459,  103,  127,  126,  148,  124,  167,  443,  235,
  /*  1390 */   608,  608,  608,  607,   15,  442,  439,  623,  234,  299,
  /*  1400 */   145,  583,  291,  377,  581,  160,  119,  156,  270,  636,
  /*  1410 */   971,  169,  279,  626,  520,  625,  473,  624,  170,  621,
  /*  1420 */   618,  119,  168,   55,  409,  423,  537,  609,  286,  285,
  /*  1430 */   405,  570,  560,  556,    5,   52,  458,  554,  147,  267,
  /*  1440 */   519,  504,  518,  406,  262,  239,  260,  512,  343,  511,
  /*  1450 */   258,  353,  565,  256,  224,  251,  359,  277,  275,  476,
  /*  1460 */   475,  246,  352,  244,  467,  455,  236,  233,  232,  307,
  /*  1470 */   441,  281,  205,  163,  397,  280,  535,  505,  330,  617,
  /*  1480 */   971,  971,  971,  971,  367,  971,  971,  971,  971,  971,
  /*  1490 */   971,  971,  971,  971,  971,  971,  338,
 };
 static const YYCODETYPE yy_lookahead[] = {
  /*     0 */    19,  142,  143,  144,  145,   24,    1,   26,   77,   78,
  /*    10 */    79,   80,   81,   82,   83,   84,   85,   86,   87,   88,
  /*    20 */    89,   90,   91,   92,   26,   27,   15,   26,   27,  197,
  /*    30 */    49,   50,   77,   78,   79,   80,  204,   82,   83,   84,
  /*    40 */    85,   86,   87,   88,   89,   90,   91,   92,   23,   68,
  /*    50 */    69,   70,   71,   72,   73,   74,   75,   76,   77,   78,
  /*    60 */    79,   80,  166,   82,   83,   84,   85,   86,   87,   88,
  /*    70 */    89,   90,   91,   92,   19,   94,   19,  105,  106,  107,
  /*    80 */    25,   82,   83,   84,   85,   86,   87,   88,   89,   90,
  /*    90 */    91,   92,   94,   95,   96,   94,   95,   99,  100,  101,
  /*   100 */   112,  205,  114,  115,   49,   50,   22,   23,  110,   54,
  /*   110 */    86,   87,   88,   89,   90,   91,   92,  221,  222,  223,
  /*   120 */    23,  120,   25,   68,   69,   70,   71,   72,   73,   74,
  /*   130 */    75,   76,   77,   78,   79,   80,   22,   82,   83,   84,
  /*   140 */    85,   86,   87,   88,   89,   90,   91,   92,   19,   92,
  /*   150 */    23,   67,   25,   96,   97,   98,   99,  100,  101,  102,
  /*   160 */   150,   32,  150,  118,   26,   27,  109,  150,  150,  150,
  /*   170 */    41,  161,  162,  180,  181,  165,  113,  165,   49,   50,
  /*   180 */   117,  188,  165,  165,  165,  173,  174,  170,  171,  170,
  /*   190 */   171,  173,  174,  118,  184,   16,  186,   68,   69,   70,
  /*   200 */    71,   72,   73,   74,   75,   76,   77,   78,   79,   80,
  /*   210 */   118,   82,   83,   84,   85,   86,   87,   88,   89,   90,
  /*   220 */    91,   92,   19,   98,   86,   87,   22,   24,  160,   88,
  /*   230 */    26,   27,   94,   95,  109,   97,  224,   66,  118,   60,
  /*   240 */   150,   62,  104,   23,  106,   25,  229,  230,  229,  230,
  /*   250 */   160,  150,   49,   50,  113,  165,   96,   26,  117,   99,
  /*   260 */   100,  101,  194,  173,  174,   94,  165,  129,  130,   98,
  /*   270 */   110,   68,   69,   70,   71,   72,   73,   74,   75,   76,
  /*   280 */    77,   78,   79,   80,  194,   82,   83,   84,   85,   86,
  /*   290 */    87,   88,   89,   90,   91,   92,   19,   11,   94,   95,
  /*   300 */   129,  130,  131,  118,  150,  215,  150,  150,  150,   25,
  /*   310 */   220,   26,   27,   22,  213,   26,   27,   26,   27,  165,
  /*   320 */    25,  165,  165,  165,   30,   94,   49,   50,   34,  173,
  /*   330 */   174,  173,  174,   88,   89,   90,   91,   92,    7,    8,
  /*   340 */   160,  187,   48,   57,  187,   68,   69,   70,   71,   72,
  /*   350 */    73,   74,   75,   76,   77,   78,   79,   80,   23,   82,
  /*   360 */    83,   84,   85,   86,   87,   88,   89,   90,   91,   92,
  /*   370 */    19,  215,  150,  215,  194,   19,  220,   88,  220,   94,
  /*   380 */    95,   23,  160,   94,   95,   94,   95,  165,   26,   27,
  /*   390 */    95,  105,  106,  107,  113,  173,  174,  217,   22,  150,
  /*   400 */    49,   50,  116,  119,   57,  120,   50,  158,   22,   21,
  /*   410 */   161,  162,  232,  136,  165,  120,  194,  237,   23,   68,
  /*   420 */    69,   70,   71,   72,   73,   74,   75,   76,   77,   78,
  /*   430 */    79,   80,   22,   82,   83,   84,   85,   86,   87,   88,
  /*   440 */    89,   90,   91,   92,   19,   23,   12,  112,   23,  114,
  /*   450 */   115,   63,  105,  106,  107,   23,   94,   95,   97,   98,
  /*   460 */   104,  150,   28,  116,   25,  109,  150,  150,   23,   23,
  /*   470 */   112,   25,  114,  115,   49,   50,  165,  150,   44,   11,
  /*   480 */    46,  165,  165,   16,  173,  174,   76,  136,  100,  173,
  /*   490 */   174,   57,  165,   68,   69,   70,   71,   72,   73,   74,
  /*   500 */    75,   76,   77,   78,   79,   80,  166,   82,   83,   84,
  /*   510 */    85,   86,   87,   88,   89,   90,   91,   92,   19,  169,
  /*   520 */   170,  171,   23,   12,   23,  214,  138,   60,  150,   62,
  /*   530 */    24,  215,   26,  216,  112,  150,  114,  115,   36,   28,
  /*   540 */   213,   95,  103,  165,  112,  205,  114,  115,   49,   50,
  /*   550 */   165,  173,  174,   51,   23,   44,   25,   46,  173,  174,
  /*   560 */    58,   22,   23,   22,   25,  160,  120,   68,   69,   70,
  /*   570 */    71,   72,   73,   74,   75,   76,   77,   78,   79,   80,
  /*   580 */   230,   82,   83,   84,   85,   86,   87,   88,   89,   90,
  /*   590 */    91,   92,   19,  215,   22,   23,   23,   25,  163,  194,
  /*   600 */    94,  166,  167,  168,   25,  138,   67,    7,    8,    9,
  /*   610 */   108,  206,  207,  169,  170,  171,  150,   22,  221,  222,
  /*   620 */   223,   26,   49,   50,   86,   87,   23,  161,  162,   23,
  /*   630 */    22,  165,   24,  120,   22,   23,   25,  160,  241,   67,
  /*   640 */   176,   68,   69,   70,   71,   72,   73,   74,   75,   76,
  /*   650 */    77,   78,   79,   80,  160,   82,   83,   84,   85,   86,
  /*   660 */    87,   88,   89,   90,   91,   92,   19,  129,  130,  150,
  /*   670 */    23,  194,   35,   23,  230,   25,  150,  155,  150,   67,
  /*   680 */   150,  105,  106,  107,  165,  221,  222,  223,  194,   94,
  /*   690 */    23,  165,   25,  165,  217,  165,   49,   50,   25,  173,
  /*   700 */   174,  173,  174,  173,  174,    0,    1,    2,  118,  221,
  /*   710 */   222,  223,  193,  219,  237,   68,   69,   70,   71,   72,
  /*   720 */    73,   74,   75,   76,   77,   78,   79,   80,  150,   82,
  /*   730 */    83,   84,   85,   86,   87,   88,   89,   90,   91,   92,
  /*   740 */    19,  150,   19,  165,  150,   24,  166,  167,  168,  227,
  /*   750 */    27,  173,  174,  231,  150,   25,  165,  150,  172,  165,
  /*   760 */   150,  242,  129,  130,  173,  174,  180,  173,  174,  165,
  /*   770 */    49,   50,  165,  150,  176,  165,   35,  173,  174,  165,
  /*   780 */   173,  174,   35,   23,   23,   25,   25,  173,  165,   68,
  /*   790 */    69,   70,   71,   72,   73,   74,   75,   76,   77,   78,
  /*   800 */    79,   80,  150,   82,   83,   84,   85,   86,   87,   88,
  /*   810 */    89,   90,   91,   92,   19,  150,  193,  165,  150,  221,
  /*   820 */   222,  223,  150,  213,   19,  173,  174,   23,  150,   97,
  /*   830 */   165,  150,   27,  165,  150,  150,  150,  165,  173,  174,
  /*   840 */    22,  173,  174,  165,   49,   50,  165,   52,  116,  165,
  /*   850 */   165,  165,  206,  207,  173,  174,  126,   50,  173,  174,
  /*   860 */   128,   27,  160,   68,   69,   70,   71,   72,   73,   74,
  /*   870 */    75,   76,   77,   78,   79,   80,  150,   82,   83,   84,
  /*   880 */    85,   86,   87,   88,   89,   90,   91,   92,   19,  150,
  /*   890 */    23,  165,  150,   23,  216,   25,  194,   32,   39,  173,
  /*   900 */   174,  135,  150,  137,  165,  150,   41,  165,  150,   52,
  /*   910 */   238,  104,  173,  174,   29,  173,  174,  165,   49,   50,
  /*   920 */   165,  219,  238,  165,  238,  173,  174,   52,  173,  174,
  /*   930 */    22,  173,  174,   23,   23,  160,   25,   68,   69,   70,
  /*   940 */    71,   72,   73,   74,   75,   76,   77,   78,   79,   80,
  /*   950 */   150,   82,   83,   84,   85,   86,   87,   88,   89,   90,
  /*   960 */    91,   92,   19,  150,  150,  165,  150,  245,  246,  194,
  /*   970 */   150,  144,  145,  173,  174,  160,  150,   22,  165,  165,
  /*   980 */    22,  165,  150,  150,  116,  165,  173,  174,   52,  173,
  /*   990 */   174,  165,   49,   50,   22,  150,  128,  165,  165,  173,
  /*  1000 */   174,  187,  166,  166,   22,  173,  174,  187,  109,  194,
  /*  1010 */   165,   68,   69,   70,   71,   72,   73,   74,   75,   76,
  /*  1020 */    77,   78,   79,   80,  150,   82,   83,   84,   85,   86,
  /*  1030 */    87,   88,   89,   90,   91,   92,   19,  150,  193,  165,
  /*  1040 */   102,  205,  205,  150,  150,  247,  248,  173,  174,   19,
  /*  1050 */   150,   20,  165,  150,  150,  150,  150,  150,  165,  165,
  /*  1060 */   173,  174,   49,   50,  104,  165,   49,   50,  165,  165,
  /*  1070 */   165,  165,  165,  173,  174,   43,  173,  174,  173,  174,
  /*  1080 */   187,   24,  190,  191,   71,   72,   69,   70,   71,   72,
  /*  1090 */    73,   74,   75,   76,   77,   78,   79,   80,  150,   82,
  /*  1100 */    83,   84,   85,   86,   87,   88,   89,   90,   91,   92,
  /*  1110 */    19,   98,  150,  165,  150,  150,  150,  150,  150,  150,
  /*  1120 */    59,  173,  174,   25,  150,  190,  191,  165,   53,  165,
  /*  1130 */   165,  165,  165,  165,  165,  173,  174,  173,  174,  165,
  /*  1140 */    49,   50,   91,   92,    1,    2,   53,  173,  174,  138,
  /*  1150 */   104,   22,    5,    1,   35,  118,  127,  150,  193,  193,
  /*  1160 */   193,   70,   71,   72,   73,   74,   75,   76,   77,   78,
  /*  1170 */    79,   80,  165,   82,   83,   84,   85,   86,   87,   88,
  /*  1180 */    89,   90,   91,   92,   19,   20,  150,   22,  150,   27,
  /*  1190 */   150,   26,   27,  108,  150,   22,   76,   76,  150,   25,
  /*  1200 */   193,  165,   37,  165,  150,  165,   22,   19,   20,  165,
  /*  1210 */    22,  173,  174,  165,   26,   27,   23,  150,  119,  165,
  /*  1220 */   150,   56,  150,  150,  150,   37,   16,  173,  174,  193,
  /*  1230 */   150,   66,  165,  193,    1,  165,  121,  165,  165,  165,
  /*  1240 */    20,  146,  147,  119,   56,  165,  150,  152,   16,  154,
  /*  1250 */   150,   86,   87,   88,   66,  160,  150,  150,   93,   94,
  /*  1260 */    95,  165,  150,   98,  108,  165,  127,   23,   65,  173,
  /*  1270 */   174,  165,  165,  150,   86,   87,  128,  165,  150,  173,
  /*  1280 */   174,   93,   94,   95,   23,  150,   98,   15,  165,  194,
  /*  1290 */   150,  140,   22,  165,  129,  130,  131,  132,  133,  134,
  /*  1300 */   165,  173,  174,    3,  116,  165,   19,   20,  150,   22,
  /*  1310 */     4,  150,  217,   26,   27,  179,  179,  129,  130,  131,
  /*  1320 */   132,  133,  134,  165,   37,  150,  165,  150,  164,   19,
  /*  1330 */    20,  150,   22,  246,  149,  249,   26,   27,  249,  244,
  /*  1340 */   165,  150,  165,   56,    6,  150,  165,   37,  173,  174,
  /*  1350 */   173,  174,  150,   66,  173,  174,  165,  149,  149,   13,
  /*  1360 */   165,   25,  150,  150,  150,  149,   56,  165,  150,  116,
  /*  1370 */   151,  150,  150,   86,   87,  150,   66,  165,  165,  165,
  /*  1380 */    93,   94,   95,  165,  150,   98,  165,  165,  151,   22,
  /*  1390 */   165,  194,  150,   26,   27,  150,   86,   87,  159,  165,
  /*  1400 */   199,  126,  123,   93,   94,   95,  200,  165,   98,  124,
  /*  1410 */   165,  122,  201,  125,  225,  135,  129,  130,  131,  132,
  /*  1420 */   133,  134,    5,  157,  157,  202,  118,   10,   11,   12,
  /*  1430 */    13,   14,  203,   66,   17,  104,  210,  121,  211,  129,
  /*  1440 */   130,  131,  132,  133,  134,  210,  175,  211,   31,  211,
  /*  1450 */    33,  210,  104,   86,   87,   47,  175,  183,  175,   42,
  /*  1460 */   103,   94,  178,  177,   22,   98,  175,   92,  228,  175,
  /*  1470 */   175,  228,   55,  183,   57,  178,  175,  156,   61,   18,
  /*  1480 */   157,   64,  156,  235,  157,  156,   45,  157,  236,  157,
  /*  1490 */   135,  156,  199,  189,  157,   68,  129,  130,  131,   22,
  /*  1500 */   189,  199,  157,  156,  192,   18,  192,  192,  199,  192,
  /*  1510 */   218,  189,   40,  157,  218,  157,  240,  240,  157,   38,
  /*  1520 */   196,  243,  105,  106,  107,  153,  198,  209,  111,  166,
  /*  1530 */   176,  181,  166,  116,  166,  230,  176,  230,  176,  226,
  /*  1540 */   199,  177,  239,  209,  185,  148,  166,  195,  209,  196,
  /*  1550 */   199,  208,  182,  233,  173,  182,  139,  186,  239,  234,
  /*  1560 */   191,  182,  173,   92,
  /*     0 */    19,   22,   22,   23,    1,   24,   26,   15,   27,   80,
  /*    10 */    81,   82,   83,   84,   85,   86,   87,   88,   89,   90,
  /*    20 */    91,   92,   93,   94,   95,  108,  109,  110,   27,   28,
  /*    30 */    23,   50,   51,   80,   81,   82,   83,  122,   85,   86,
  /*    40 */    87,   88,   89,   90,   91,   92,   93,   94,   95,   22,
  /*    50 */    70,   23,   71,   72,   73,   74,   75,   76,   77,   78,
  /*    60 */    79,   80,   81,   82,   83,  122,   85,   86,   87,   88,
  /*    70 */    89,   90,   91,   92,   93,   94,   95,   19,   97,   91,
  /*    80 */    92,   93,   94,   95,   26,   85,   86,   87,   88,   89,
  /*    90 */    90,   91,   92,   93,   94,   95,   27,   28,   97,   98,
  /*   100 */    99,  122,  211,  102,  103,  104,   79,   19,   50,   51,
  /*   110 */    19,  122,   59,   55,  113,  224,  225,  226,   89,   90,
  /*   120 */    91,   92,   93,   94,   95,   23,   27,   28,   26,   71,
  /*   130 */    72,   73,   74,   75,   76,   77,   78,   79,   80,   81,
  /*   140 */    82,   83,   51,   85,   86,   87,   88,   89,   90,   91,
  /*   150 */    92,   93,   94,   95,   19,  132,  133,   58,   89,   90,
  /*   160 */    21,  108,  109,  110,   27,   28,   97,   98,   33,  100,
  /*   170 */     7,    8,  119,  120,   22,   19,  107,   42,  109,   27,
  /*   180 */    28,   27,   28,   95,   28,   50,   51,   99,  100,  101,
  /*   190 */   102,  103,  104,  105,   27,   28,   97,   98,  107,  152,
  /*   200 */   112,  132,  133,  112,   65,   69,   71,   72,   73,   74,
  /*   210 */    75,   76,   77,   78,   79,   80,   81,   82,   83,   11,
  /*   220 */    85,   86,   87,   88,   89,   90,   91,   92,   93,   94,
  /*   230 */    95,   19,  101,   97,   97,   98,   24,  101,  122,  157,
  /*   240 */    12,   99,  103,  112,  102,  103,  104,  152,   22,   97,
  /*   250 */    98,   97,   98,   27,   28,  113,   27,   29,   91,  164,
  /*   260 */   165,  124,   50,   51,   97,   98,  219,   59,  132,  133,
  /*   270 */   134,   22,   23,   45,   66,   47,  212,  213,  124,  140,
  /*   280 */   132,  133,   19,   71,   72,   73,   74,   75,   76,   77,
  /*   290 */    78,   79,   80,   81,   82,   83,  152,   85,   86,   87,
  /*   300 */    88,   89,   90,   91,   92,   93,   94,   95,  164,  165,
  /*   310 */    27,   28,  230,   50,   51,  233,  108,  109,  110,   70,
  /*   320 */    16,   59,   23,   97,   98,   26,   97,   22,   66,  185,
  /*   330 */    12,  187,   27,   28,   71,   72,   73,   74,   75,   76,
  /*   340 */    77,   78,   79,   80,   81,   82,   83,   29,   85,   86,
  /*   350 */    87,   88,   89,   90,   91,   92,   93,   94,   95,   19,
  /*   360 */    22,  148,  149,   45,   23,   47,   62,  154,   64,  156,
  /*   370 */   108,  109,  110,   37,   69,   23,  163,   59,   26,   26,
  /*   380 */    97,   98,  144,  145,  146,  147,  152,  200,   52,   23,
  /*   390 */    50,   51,   26,   22,   89,   90,   60,  210,    7,    8,
  /*   400 */     9,  138,   97,   22,   23,   26,  101,   26,  174,  175,
  /*   410 */   197,   71,   72,   73,   74,   75,   76,   77,   78,   79,
  /*   420 */    80,   81,   82,   83,   16,   85,   86,   87,   88,   89,
  /*   430 */    90,   91,   92,   93,   94,   95,   19,  132,  133,  134,
  /*   440 */    23,  152,  208,  209,  140,  152,  152,  111,  195,  196,
  /*   450 */    98,   70,  163,  160,  152,   23,   22,  164,  165,  246,
  /*   460 */   207,   27,  152,  174,  175,  171,  172,   50,   51,  137,
  /*   470 */    62,  139,   64,  171,  172,  222,  124,   27,  138,   24,
  /*   480 */   163,   89,   90,  130,  174,  175,  197,  163,   71,   72,
  /*   490 */    73,   74,   75,   76,   77,   78,   79,   80,   81,   82,
  /*   500 */    83,   22,   85,   86,   87,   88,   89,   90,   91,   92,
  /*   510 */    93,   94,   95,   19,  197,  181,  182,   23,  208,  209,
  /*   520 */   152,  197,   26,  189,  132,  133,  232,  224,  225,  226,
  /*   530 */   152,   97,   91,   26,  232,  116,  212,  213,  152,  222,
  /*   540 */   121,  152,  174,  175,   50,   51,  243,   97,   22,   23,
  /*   550 */    22,  234,  174,  175,  177,   23,  239,  116,  163,  177,
  /*   560 */   174,  175,  121,  174,  175,   71,   72,   73,   74,   75,
  /*   570 */    76,   77,   78,   79,   80,   81,   82,   83,   24,   85,
  /*   580 */    86,   87,   88,   89,   90,   91,   92,   93,   94,   95,
  /*   590 */    19,   23,  197,   11,   23,  227,   70,  208,  220,  152,
  /*   600 */    31,  224,  225,  226,   35,   98,  224,  225,  226,  108,
  /*   610 */   109,  110,  115,  152,  117,  118,   27,  222,   49,  123,
  /*   620 */    24,   50,   51,   27,    0,    1,    2,  224,  225,  226,
  /*   630 */   166,  124,  168,  169,  239,  174,  175,  170,  171,  172,
  /*   640 */    22,  194,   71,   72,   73,   74,   75,   76,   77,   78,
  /*   650 */    79,   80,   81,   82,   83,  152,   85,   86,   87,   88,
  /*   660 */    89,   90,   91,   92,   93,   94,   95,   19,   22,  208,
  /*   670 */    24,   23,  195,  196,  170,  171,  172,  174,  175,  152,
  /*   680 */    26,  152,  152,  152,  207,  152,   97,  152,   23,  152,
  /*   690 */    51,  244,  152,   97,  152,  247,  248,   23,   50,   51,
  /*   700 */    26,  174,  175,  174,  175,  174,  175,  174,  175,  174,
  /*   710 */   175,  174,  175,   23,  174,  175,  174,  175,  188,   71,
  /*   720 */    72,   73,   74,   75,   76,   77,   78,   79,   80,   81,
  /*   730 */    82,   83,  152,   85,   86,   87,   88,   89,   90,   91,
  /*   740 */    92,   93,   94,   95,   19,  152,  107,  152,   33,   24,
  /*   750 */   152,  100,  101,   27,  174,  175,  152,   42,  152,   23,
  /*   760 */   152,   26,  152,   23,  152,   26,  152,  174,  175,  174,
  /*   770 */   175,  152,  174,  175,   23,   50,   51,   26,  174,  175,
  /*   780 */   174,  175,  174,  175,  174,  175,  174,  175,  174,  175,
  /*   790 */   163,  119,  120,  174,  175,   19,   71,   72,   73,   74,
  /*   800 */    75,   76,   77,   78,   79,   80,   81,   82,   83,  152,
  /*   810 */    85,   86,   87,   88,   89,   90,   91,   92,   93,   94,
  /*   820 */    95,   66,  152,   97,  197,   23,   50,   51,   26,   53,
  /*   830 */    23,  174,  175,   26,   23,   23,   23,   26,   26,   26,
  /*   840 */    36,  106,  146,  147,  174,  175,   19,   71,   72,   73,
  /*   850 */    74,   75,   76,   77,   78,   79,   80,   81,   82,   83,
  /*   860 */   152,   85,   86,   87,   88,   89,   90,   91,   92,   93,
  /*   870 */    94,   95,  152,  196,  119,  120,   19,   50,   51,  168,
  /*   880 */   169,   26,  174,  175,  207,   28,  152,  249,  250,  152,
  /*   890 */   163,  163,  163,  163,  174,  175,  163,   19,   71,   72,
  /*   900 */    73,   74,   75,   76,   77,   78,   79,   80,   81,   82,
  /*   910 */    83,  152,   85,   86,   87,   88,   89,   90,   91,   92,
  /*   920 */    93,   94,   95,  152,  197,  197,  197,  197,   50,   51,
  /*   930 */   197,  194,   36,  174,  175,  191,  192,  152,  191,  192,
  /*   940 */   163,  152,   66,  124,  152,  174,  175,  152,   19,   71,
  /*   950 */    72,   73,   74,   75,   76,   77,   78,   79,   80,   81,
  /*   960 */    82,   83,  152,   85,   86,   87,   88,   89,   90,   91,
  /*   970 */    92,   93,   94,   95,  197,  152,  100,  188,  152,   50,
  /*   980 */    51,  152,  152,  188,  174,  175,  252,  152,   94,   95,
  /*   990 */   152,  152,  152,    1,    2,  152,  152,  174,  175,   19,
  /*  1000 */   152,   72,   73,   74,   75,   76,   77,   78,   79,   80,
  /*  1010 */    81,   82,   83,  152,   85,   86,   87,   88,   89,   90,
  /*  1020 */    91,   92,   93,   94,   95,  152,  188,  188,   22,  194,
  /*  1030 */    50,   51,  240,  173,  194,  174,  175,  252,  194,  152,
  /*  1040 */    36,  181,   28,  152,   23,  219,  122,  174,  175,  219,
  /*  1050 */   221,  152,  152,   73,   74,   75,   76,   77,   78,   79,
  /*  1060 */    80,   81,   82,   83,  152,   85,   86,   87,   88,   89,
  /*  1070 */    90,   91,   92,   93,   94,   95,   19,   20,  152,   22,
  /*  1080 */    23,  194,  152,  240,   27,   28,  174,  175,  240,   19,
  /*  1090 */    20,   26,   22,  194,  194,   38,   22,   27,   28,  152,
  /*  1100 */    23,   22,  152,  116,  174,  175,  152,   23,   38,  152,
  /*  1110 */    23,  152,  221,  152,   57,  152,   23,  163,   50,   51,
  /*  1120 */   194,  174,  175,   66,  174,  175,   69,   57,  174,  175,
  /*  1130 */    40,  174,  175,  174,  175,  174,  175,  174,  175,   69,
  /*  1140 */    22,   53,   74,   75,   30,   53,   89,   90,   22,   22,
  /*  1150 */   152,  197,   23,   96,   97,   98,   22,  152,  101,   89,
  /*  1160 */    90,   91,  208,  209,  152,   53,   96,   97,   98,  101,
  /*  1170 */    22,  101,  174,  175,  152,   19,   20,  105,   22,  174,
  /*  1180 */   175,  112,   19,   27,   28,   20,  174,  175,   24,  132,
  /*  1190 */   133,  134,  135,  136,   38,   44,  174,  175,  107,   61,
  /*  1200 */    54,   26,  132,  133,  134,  135,  136,   54,  107,   22,
  /*  1210 */     5,  140,    1,   57,   36,  111,  122,   28,   79,   79,
  /*  1220 */   131,  123,   66,   19,   20,   69,   22,    1,   16,   20,
  /*  1230 */   125,   27,   28,  123,  111,  120,   23,  131,   23,   16,
  /*  1240 */    68,  142,   38,   15,   22,   89,   90,    3,  167,    4,
  /*  1250 */   248,  251,   96,   97,   98,  180,  180,  101,  251,  151,
  /*  1260 */     6,   57,  151,   13,  151,   26,   25,  151,  161,  202,
  /*  1270 */   153,  162,  153,   69,  130,  128,  203,   19,   20,  127,
  /*  1280 */    22,  126,  204,  129,   22,   27,   28,  205,  132,  133,
  /*  1290 */   134,  135,  136,   89,   90,  231,   38,   95,  137,  179,
  /*  1300 */    96,   97,   98,  206,  179,  101,  122,  107,  159,  159,
  /*  1310 */   125,  231,  216,  228,  107,   57,  184,  217,  216,  176,
  /*  1320 */   217,  176,   48,  106,   18,  184,  158,   69,  159,  158,
  /*  1330 */    46,   71,  237,  176,  176,  176,  132,  133,  134,  135,
  /*  1340 */   136,  217,  176,  137,  216,  178,  158,   89,   90,  179,
  /*  1350 */   176,  159,  179,  159,   96,   97,   98,  159,  159,  101,
  /*  1360 */     5,  158,  202,   22,   18,   10,   11,   12,   13,   14,
  /*  1370 */   190,  238,   17,  190,  158,  193,   41,  159,  202,  193,
  /*  1380 */   159,  202,  245,  193,  193,  223,  190,   32,  159,   34,
  /*  1390 */   132,  133,  134,  135,  136,  159,   39,  155,   43,  150,
  /*  1400 */   223,  177,  201,  178,  177,  186,   66,  199,  177,  152,
  /*  1410 */   253,   56,  215,  152,  182,  152,  202,  152,   63,  152,
  /*  1420 */   152,   66,   67,  242,  229,  152,  174,  152,  152,  152,
  /*  1430 */   152,  152,  152,  152,  199,  242,  202,  152,  198,  152,
  /*  1440 */   152,  152,  183,  192,  152,  215,  152,  183,  215,  183,
  /*  1450 */   152,  241,  214,  152,  211,  152,  152,  211,  211,  152,
  /*  1460 */   152,  241,  152,  152,  152,  152,  152,  152,  152,  114,
  /*  1470 */   152,  152,  235,  152,  152,  152,  174,  187,   95,  174,
  /*  1480 */   253,  253,  253,  253,  236,  253,  253,  253,  253,  253,
  /*  1490 */   253,  253,  253,  253,  253,  253,  141,
 };
 #define YY_SHIFT_USE_DFLT (-70)
 #define YY_SHIFT_COUNT (417)
 #define YY_SHIFT_MIN   (-69)
 #define YY_SHIFT_MAX   (1487)
 #define YY_SHIFT_USE_DFLT (-86)
 #define YY_SHIFT_COUNT (429)
 #define YY_SHIFT_MIN   (-85)
 #define YY_SHIFT_MAX   (1383)
 static const short yy_shift_ofst[] = {
  /*     0 */  1143, 1188, 1417, 1188, 1287, 1287,  138,  138,   -2,  -19,
  /*    10 */  1287, 1287, 1287, 1287,  347,  362,  129,  129,  795, 1165,
  /*    20 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
  /*    30 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
  /*    40 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1310, 1287,
  /*    50 */  1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287, 1287,
  /*    60 */  1287, 1287,  286,  362,  362,  538,  538,  231, 1253,   55,
  /*    70 */   721,  647,  573,  499,  425,  351,  277,  203,  869,  869,
  /*    80 */   869,  869,  869,  869,  869,  869,  869,  869,  869,  869,
  /*    90 */   869,  869,  869,  943,  869, 1017, 1091, 1091,  -69,  -45,
  /*   100 */   -45,  -45,  -45,  -45,   -1,   24,  245,  362,  362,  362,
  /*   110 */   362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
  /*   120 */   362,  362,  362,  388,  356,  362,  362,  362,  362,  362,
  /*   130 */   732,  868,  231, 1051, 1471,  -70,  -70,  -70, 1367,   57,
  /*   140 */   434,  434,  289,  291,  285,    1,  204,  572,  539,  362,
  /*   150 */   362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
  /*   160 */   362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
  /*   170 */   362,  362,  362,  362,  362,  362,  362,  362,  362,  362,
  /*   180 */   362,  506,  506,  506,  705, 1253, 1253, 1253,  -70,  -70,
  /*   190 */   -70,  171,  171,  160,  502,  502,  502,  446,  432,  511,
  /*   200 */   422,  358,  335,  -12,  -12,  -12,  -12,  576,  294,  -12,
  /*   210 */   -12,  295,  595,  141,  600,  730,  723,  723,  805,  730,
  /*   220 */   805,  439,  911,  231,  865,  231,  865,  807,  865,  723,
  /*   230 */   766,  633,  633,  231,  284,   63,  608, 1481, 1308, 1308,
  /*   240 */  1472, 1472, 1308, 1477, 1427, 1275, 1487, 1487, 1487, 1487,
  /*   250 */  1308, 1461, 1275, 1477, 1427, 1427, 1275, 1308, 1461, 1355,
  /*   260 */  1441, 1308, 1308, 1461, 1308, 1461, 1308, 1461, 1442, 1348,
  /*   270 */  1348, 1348, 1408, 1375, 1375, 1442, 1348, 1357, 1348, 1408,
  /*   280 */  1348, 1348, 1316, 1331, 1316, 1331, 1316, 1331, 1308, 1308,
  /*   290 */  1280, 1288, 1289, 1285, 1279, 1275, 1253, 1336, 1346, 1346,
  /*   300 */  1338, 1338, 1338, 1338,  -70,  -70,  -70,  -70,  -70,  -70,
  /*   310 */  1013,  467,  612,   84,  179,  -28,  870,  410,  761,  760,
  /*   320 */   667,  650,  531,  220,  361,  331,  125,  127,   97, 1306,
  /*   330 */  1300, 1270, 1151, 1272, 1203, 1232, 1261, 1244, 1148, 1174,
  /*   340 */  1139, 1156, 1124, 1220, 1115, 1210, 1233, 1099, 1193, 1184,
  /*   350 */  1174, 1173, 1029, 1121, 1120, 1085, 1162, 1119, 1037, 1152,
  /*   360 */  1147, 1129, 1046, 1011, 1093, 1098, 1075, 1061, 1032,  960,
  /*   370 */  1057, 1031, 1030,  899,  938,  982,  936,  972,  958,  910,
  /*   380 */   955,  875,  885,  908,  857,  859,  867,  804,  590,  834,
  /*   390 */   747,  818,  513,  611,  741,  673,  637,  611,  606,  603,
  /*   400 */   579,  501,  541,  468,  386,  445,  395,  376,  281,  185,
  /*   410 */   120,   92,   75,   45,  114,   25,   11,    5,
  /*     0 */   992, 1057, 1355, 1156, 1204, 1204,    1,  262,  -19,  135,
  /*    10 */   135,  776, 1204, 1204, 1204, 1204,   69,   69,   53,  208,
  /*    20 */   283,  755,   58,  725,  648,  571,  494,  417,  340,  263,
  /*    30 */   212,  827,  827,  827,  827,  827,  827,  827,  827,  827,
  /*    40 */   827,  827,  827,  827,  827,  827,  878,  827,  929,  980,
  /*    50 */   980, 1070, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204,
  /*    60 */  1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204,
  /*    70 */  1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204,
  /*    80 */  1258, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204, 1204,
  /*    90 */  1204, 1204, 1204, 1204,  -71,  -47,  -47,  -47,  -47,  -47,
  /*   100 */     0,   29,  -12,  283,  283,  139,   91,  392,  392,  894,
  /*   110 */   672,  726, 1383,  -86,  -86,  -86,   88,  318,  318,   99,
  /*   120 */   381,  -20,  283,  283,  283,  283,  283,  283,  283,  283,
  /*   130 */   283,  283,  283,  283,  283,  283,  283,  283,  283,  283,
  /*   140 */   283,  283,  283,  283,  624,  876,  726,  672, 1340, 1340,
  /*   150 */  1340, 1340, 1340, 1340,  -86,  -86,  -86,  305,  136,  136,
  /*   160 */   142,  167,  226,  154,  137,  152,  283,  283,  283,  283,
  /*   170 */   283,  283,  283,  283,  283,  283,  283,  283,  283,  283,
  /*   180 */   283,  283,  283,  336,  336,  336,  283,  283,  352,  283,
  /*   190 */   283,  283,  283,  283,  228,  283,  283,  283,  283,  283,
  /*   200 */   283,  283,  283,  283,  283,  501,  569,  596,  596,  596,
  /*   210 */   507,  497,  441,  391,  353,  156,  156,  857,  353,  857,
  /*   220 */   735,  813,  639,  715,  156,  332,  715,  715,  496,  419,
  /*   230 */   646, 1357, 1184, 1184, 1335, 1335, 1184, 1341, 1260, 1144,
  /*   240 */  1346, 1346, 1346, 1346, 1184, 1306, 1144, 1341, 1260, 1260,
  /*   250 */  1144, 1184, 1306, 1206, 1284, 1184, 1184, 1306, 1184, 1306,
  /*   260 */  1184, 1306, 1262, 1207, 1207, 1207, 1274, 1262, 1207, 1217,
  /*   270 */  1207, 1274, 1207, 1207, 1185, 1200, 1185, 1200, 1185, 1200,
  /*   280 */  1184, 1184, 1161, 1262, 1202, 1202, 1262, 1154, 1155, 1147,
  /*   290 */  1152, 1144, 1241, 1239, 1250, 1250, 1254, 1254, 1254, 1254,
  /*   300 */   -86,  -86,  -86,  -86,  -86,  -86, 1068,  304,  526,  249,
  /*   310 */   408,  -83,  434,  812,   27,  811,  807,  802,  751,  589,
  /*   320 */   651,  163,  131,  674,  366,  450,  299,  148,   23,  102,
  /*   330 */   229,  -21, 1245, 1244, 1222, 1099, 1228, 1172, 1223, 1215,
  /*   340 */  1213, 1115, 1106, 1123, 1110, 1209, 1105, 1212, 1226, 1098,
  /*   350 */  1089, 1140, 1139, 1104, 1189, 1178, 1094, 1211, 1205, 1187,
  /*   360 */  1101, 1071, 1153, 1175, 1146, 1138, 1151, 1091, 1164, 1165,
  /*   370 */  1163, 1069, 1072, 1148, 1112, 1134, 1127, 1129, 1126, 1092,
  /*   380 */  1114, 1118, 1088, 1090, 1093, 1087, 1084,  987, 1079, 1077,
  /*   390 */  1074, 1065,  924, 1021, 1014, 1004, 1006,  819,  739,  896,
  /*   400 */   855,  804,  739,  740,  736,  690,  654,  665,  618,  582,
  /*   410 */   568,  528,  554,  379,  532,  479,  455,  379,  432,  371,
  /*   420 */   341,   28,  338,  116,  -11,  -57,  -85,    7,   -8,    3,
 };
 #define YY_REDUCE_USE_DFLT (-169)
 #define YY_REDUCE_COUNT (309)
 #define YY_REDUCE_MIN   (-168)
 #define YY_REDUCE_MAX   (1397)
 #define YY_REDUCE_USE_DFLT (-110)
 #define YY_REDUCE_COUNT (305)
 #define YY_REDUCE_MIN   (-109)
 #define YY_REDUCE_MAX   (1323)
 static const short yy_reduce_ofst[] = {
  /*     0 */  -141,   90, 1095,  222,  158,  156,   19,   17,   10, -104,
  /*    10 */   378,  316,  311,   12,  180,  249,  598,  464,  397, 1181,
  /*    20 */  1177, 1175, 1128, 1106, 1096, 1054, 1038,  974,  964,  962,
  /*    30 */   948,  905,  903,  900,  887,  874,  832,  826,  816,  813,
  /*    40 */   800,  758,  755,  752,  742,  739,  726,  685,  681,  668,
  /*    50 */   665,  652,  607,  604,  594,  591,  578,  530,  528,  526,
  /*    60 */   385,   18,  477,  466,  519,  444,  350,  435,  405,  488,
  /*    70 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
  /*    80 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
  /*    90 */   488,  488,  488,  488,  488,  488,  488,  488,  488,  488,
  /*   100 */   488,  488,  488,  488,  488,  488,  488, 1040,  678, 1036,
  /*   110 */  1007,  967,  966,  965,  845,  686,  610,  684,  317,  672,
  /*   120 */   893,  327,  623,  522,   -7,  820,  814,  157,  154,  101,
  /*   130 */   702,  494,  580,  488,  488,  488,  488,  488,  614,  586,
  /*   140 */   935,  892,  968, 1245, 1242, 1234, 1225,  798,  798, 1222,
  /*   150 */  1221, 1218, 1214, 1213, 1212, 1202, 1195, 1191, 1161, 1158,
  /*   160 */  1140, 1135, 1123, 1112, 1107, 1100, 1080, 1074, 1073, 1072,
  /*   170 */  1070, 1067, 1048, 1044,  969,  968,  907,  906,  904,  894,
  /*   180 */   833,  837,  836,  340,  827,  815,  775,   68,  722,  646,
  /*   190 */  -168, 1389, 1381, 1371, 1379, 1373, 1370, 1343, 1352, 1369,
  /*   200 */  1352, 1352, 1352, 1352, 1352, 1352, 1352, 1325, 1320, 1352,
  /*   210 */  1352, 1343, 1380, 1353, 1397, 1351, 1339, 1334, 1319, 1341,
  /*   220 */  1303, 1364, 1359, 1368, 1362, 1366, 1360, 1350, 1354, 1318,
  /*   230 */  1313, 1307, 1305, 1363, 1328, 1324, 1372, 1278, 1361, 1358,
  /*   240 */  1277, 1276, 1356, 1296, 1322, 1309, 1317, 1315, 1314, 1312,
  /*   250 */  1345, 1347, 1302, 1292, 1311, 1304, 1293, 1337, 1335, 1252,
  /*   260 */  1248, 1332, 1330, 1329, 1327, 1326, 1323, 1321, 1297, 1301,
  /*   270 */  1295, 1294, 1290, 1243, 1240, 1284, 1291, 1286, 1283, 1274,
  /*   280 */  1281, 1271, 1238, 1241, 1236, 1235, 1227, 1226, 1267, 1266,
  /*   290 */  1189, 1229, 1223, 1211, 1206, 1201, 1197, 1239, 1237, 1219,
  /*   300 */  1216, 1209, 1208, 1185, 1089, 1086, 1087, 1137, 1136, 1164,
  /*     0 */   238,  954,  213,  289,  310,  234,  144,  317, -109,  382,
  /*    10 */   377,  303,  461,  389,  378,  368,  302,  294,  253,  395,
  /*    20 */   293,  324,  403,  403,  403,  403,  403,  403,  403,  403,
  /*    30 */   403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
  /*    40 */   403,  403,  403,  403,  403,  403,  403,  403,  403,  403,
  /*    50 */   403, 1022, 1012, 1005,  998,  963,  961,  959,  957,  950,
  /*    60 */   947,  930,  912,  873,  861,  823,  810,  771,  759,  720,
  /*    70 */   708,  670,  657,  619,  614,  612,  610,  608,  606,  604,
  /*    80 */   598,  595,  593,  580,  542,  540,  537,  535,  533,  531,
  /*    90 */   529,  527,  503,  386,  403,  403,  403,  403,  403,  403,
  /*   100 */   403,  403,  403,   95,  447,   82,  334,  504,  467,  403,
  /*   110 */   477,  464,  403,  403,  403,  403,  860,  747,  744,  785,
  /*   120 */   638,  638,  926,  891,  900,  899,  887,  844,  840,  835,
  /*   130 */   848,  830,  843,  829,  792,  839,  826,  737,  838,  795,
  /*   140 */   789,   47,  734,  530,  696,  777,  711,  677,  733,  730,
  /*   150 */   729,  728,  727,  627,  448,   64,  187, 1305, 1302, 1252,
  /*   160 */  1290, 1273, 1323, 1322, 1321, 1319, 1318, 1316, 1315, 1314,
  /*   170 */  1313, 1312, 1311, 1310, 1308, 1307, 1304, 1303, 1301, 1298,
  /*   180 */  1294, 1292, 1289, 1266, 1264, 1259, 1288, 1287, 1238, 1285,
  /*   190 */  1281, 1280, 1279, 1278, 1251, 1277, 1276, 1275, 1273, 1268,
  /*   200 */  1267, 1265, 1263, 1261, 1257, 1248, 1237, 1247, 1246, 1243,
  /*   210 */  1238, 1240, 1235, 1249, 1234, 1233, 1230, 1220, 1214, 1210,
  /*   220 */  1225, 1219, 1232, 1231, 1197, 1195, 1227, 1224, 1201, 1208,
  /*   230 */  1242, 1137, 1236, 1229, 1193, 1181, 1221, 1177, 1196, 1179,
  /*   240 */  1191, 1190, 1186, 1182, 1218, 1216, 1176, 1162, 1183, 1180,
  /*   250 */  1160, 1199, 1203, 1133, 1095, 1198, 1194, 1188, 1192, 1171,
  /*   260 */  1169, 1168, 1173, 1174, 1166, 1159, 1141, 1170, 1158, 1167,
  /*   270 */  1157, 1132, 1145, 1143, 1124, 1128, 1103, 1102, 1100, 1096,
  /*   280 */  1150, 1149, 1085, 1125, 1080, 1064, 1120, 1097, 1082, 1078,
  /*   290 */  1073, 1067, 1109, 1107, 1119, 1117, 1116, 1113, 1111, 1108,
  /*   300 */  1007, 1000, 1002, 1076, 1075, 1081,
 };
 static const YYACTIONTYPE yy_default[] = {
  /*     0 */   633,  867,  955,  955,  867,  867,  955,  955,  955,  757,
  /*    10 */   955,  955,  955,  865,  955,  955,  785,  785,  929,  955,
  /*    20 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*    30 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*    40 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*    50 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*    60 */   955,  955,  955,  955,  955,  955,  955,  672,  761,  791,
  /*    70 */   955,  955,  955,  955,  955,  955,  955,  955,  928,  930,
  /*    80 */   799,  798,  908,  772,  796,  789,  793,  868,  861,  862,
  /*    90 */   860,  864,  869,  955,  792,  828,  845,  827,  839,  844,
  /*   100 */   851,  843,  840,  830,  829,  831,  832,  955,  955,  955,
  /*   110 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*   120 */   955,  955,  955,  659,  726,  955,  955,  955,  955,  955,
  /*   130 */   955,  955,  955,  833,  834,  848,  847,  846,  955,  664,
  /*   140 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*   150 */   935,  933,  955,  880,  955,  955,  955,  955,  955,  955,
  /*   160 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*   170 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*   180 */   639,  757,  757,  757,  633,  955,  955,  955,  947,  761,
  /*   190 */   751,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*   200 */   955,  955,  955,  801,  740,  918,  920,  955,  901,  738,
  /*   210 */   661,  759,  674,  749,  641,  795,  774,  774,  913,  795,
  /*   220 */   913,  697,  720,  955,  785,  955,  785,  694,  785,  774,
  /*   230 */   863,  955,  955,  955,  758,  749,  955,  940,  765,  765,
  /*   240 */   932,  932,  765,  807,  730,  795,  737,  737,  737,  737,
  /*   250 */   765,  656,  795,  807,  730,  730,  795,  765,  656,  907,
  /*   260 */   905,  765,  765,  656,  765,  656,  765,  656,  873,  728,
  /*   270 */   728,  728,  712,  877,  877,  873,  728,  697,  728,  712,
  /*   280 */   728,  728,  778,  773,  778,  773,  778,  773,  765,  765,
  /*   290 */   955,  790,  779,  788,  786,  795,  955,  715,  649,  649,
  /*   300 */   638,  638,  638,  638,  952,  952,  947,  699,  699,  682,
  /*   310 */   955,  955,  955,  955,  955,  955,  955,  882,  955,  955,
  /*   320 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*   330 */   634,  942,  955,  955,  939,  955,  955,  955,  955,  800,
  /*   340 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*   350 */   917,  955,  955,  955,  955,  955,  955,  955,  911,  955,
  /*   360 */   955,  955,  955,  955,  955,  904,  903,  955,  955,  955,
  /*   370 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*   380 */   955,  955,  955,  955,  955,  955,  955,  955,  955,  955,
  /*   390 */   955,  955,  955,  787,  955,  780,  955,  866,  955,  955,
  /*   400 */   955,  955,  955,  955,  955,  955,  955,  955,  743,  816,
  /*   410 */   955,  815,  819,  814,  666,  955,  647,  955,  630,  635,
  /*   420 */   951,  954,  953,  950,  949,  948,  943,  941,  938,  937,
  /*   430 */   936,  934,  931,  927,  886,  884,  891,  890,  889,  888,
  /*   440 */   887,  885,  883,  881,  802,  797,  794,  926,  879,  739,
  /*   450 */   736,  735,  655,  944,  910,  919,  806,  805,  808,  916,
  /*   460 */   915,  914,  912,  909,  896,  804,  803,  731,  871,  870,
  /*   470 */   658,  900,  899,  898,  902,  906,  897,  767,  657,  654,
  /*   480 */   663,  718,  719,  727,  725,  724,  723,  722,  721,  717,
  /*   490 */   665,  673,  711,  696,  695,  876,  878,  875,  874,  704,
  /*   500 */   703,  709,  708,  707,  706,  705,  702,  701,  700,  693,
  /*   510 */   692,  698,  691,  714,  713,  710,  690,  734,  733,  732,
  /*   520 */   729,  689,  688,  687,  819,  686,  685,  825,  824,  812,
  /*   530 */   855,  754,  753,  752,  764,  763,  776,  775,  810,  809,
  /*   540 */   777,  762,  756,  755,  771,  770,  769,  768,  760,  750,
  /*   550 */   782,  784,  783,  781,  857,  766,  854,  925,  924,  923,
  /*   560 */   922,  921,  859,  858,  826,  823,  677,  678,  894,  893,
  /*   570 */   895,  892,  680,  679,  676,  675,  856,  745,  744,  852,
  /*   580 */   849,  841,  837,  853,  850,  842,  838,  836,  835,  821,
  /*   590 */   820,  818,  817,  813,  822,  668,  746,  742,  741,  811,
  /*   600 */   748,  747,  684,  683,  681,  662,  660,  653,  651,  650,
  /*   610 */   652,  648,  646,  645,  644,  643,  642,  671,  670,  669,
  /*   620 */   667,  666,  640,  637,  636,  632,  631,  629,
  /*     0 */   647,  964,  964,  964,  878,  878,  969,  964,  774,  802,
  /*    10 */   802,  938,  969,  969,  969,  876,  969,  969,  969,  964,
  /*    20 */   969,  778,  808,  969,  969,  969,  969,  969,  969,  969,
  /*    30 */   969,  937,  939,  816,  815,  918,  789,  813,  806,  810,
  /*    40 */   879,  872,  873,  871,  875,  880,  969,  809,  841,  856,
  /*    50 */   840,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*    60 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*    70 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*    80 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*    90 */   969,  969,  969,  969,  850,  855,  862,  854,  851,  843,
  /*   100 */   842,  844,  845,  969,  969,  673,  739,  969,  969,  846,
  /*   110 */   969,  685,  847,  859,  858,  857,  680,  969,  969,  969,
  /*   120 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*   130 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*   140 */   969,  969,  969,  969,  647,  964,  969,  969,  964,  964,
  /*   150 */   964,  964,  964,  964,  956,  778,  768,  969,  969,  969,
  /*   160 */   969,  969,  969,  969,  969,  969,  969,  944,  942,  969,
  /*   170 */   891,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*   180 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*   190 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*   200 */   969,  969,  969,  969,  653,  969,  911,  774,  774,  774,
  /*   210 */   776,  754,  766,  655,  812,  791,  791,  923,  812,  923,
  /*   220 */   710,  733,  707,  802,  791,  874,  802,  802,  775,  766,
  /*   230 */   969,  949,  782,  782,  941,  941,  782,  821,  743,  812,
  /*   240 */   750,  750,  750,  750,  782,  670,  812,  821,  743,  743,
  /*   250 */   812,  782,  670,  917,  915,  782,  782,  670,  782,  670,
  /*   260 */   782,  670,  884,  741,  741,  741,  725,  884,  741,  710,
  /*   270 */   741,  725,  741,  741,  795,  790,  795,  790,  795,  790,
  /*   280 */   782,  782,  969,  884,  888,  888,  884,  807,  796,  805,
  /*   290 */   803,  812,  676,  728,  663,  663,  652,  652,  652,  652,
  /*   300 */   961,  961,  956,  712,  712,  695,  969,  969,  969,  969,
  /*   310 */   969,  969,  687,  969,  893,  969,  969,  969,  969,  969,
  /*   320 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*   330 */   969,  828,  969,  648,  951,  969,  969,  948,  969,  969,
  /*   340 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*   350 */   969,  969,  969,  969,  969,  969,  921,  969,  969,  969,
  /*   360 */   969,  969,  969,  914,  913,  969,  969,  969,  969,  969,
  /*   370 */   969,  969,  969,  969,  969,  969,  969,  969,  969,  969,
  /*   380 */   969,  969,  969,  969,  969,  969,  969,  757,  969,  969,
  /*   390 */   969,  761,  969,  969,  969,  969,  969,  969,  804,  969,
  /*   400 */   797,  969,  877,  969,  969,  969,  969,  969,  969,  969,
  /*   410 */   969,  969,  969,  966,  969,  969,  969,  965,  969,  969,
  /*   420 */   969,  969,  969,  830,  969,  829,  833,  969,  661,  969,
  /*   430 */   644,  649,  960,  963,  962,  959,  958,  957,  952,  950,
  /*   440 */   947,  946,  945,  943,  940,  936,  897,  895,  902,  901,
  /*   450 */   900,  899,  898,  896,  894,  892,  818,  817,  814,  811,
  /*   460 */   753,  935,  890,  752,  749,  748,  669,  953,  920,  929,
  /*   470 */   928,  927,  822,  926,  925,  924,  922,  919,  906,  820,
  /*   480 */   819,  744,  882,  881,  672,  910,  909,  908,  912,  916,
  /*   490 */   907,  784,  751,  671,  668,  675,  679,  731,  732,  740,
  /*   500 */   738,  737,  736,  735,  734,  730,  681,  686,  724,  709,
  /*   510 */   708,  717,  716,  722,  721,  720,  719,  718,  715,  714,
  /*   520 */   713,  706,  705,  711,  704,  727,  726,  723,  703,  747,
  /*   530 */   746,  745,  742,  702,  701,  700,  833,  699,  698,  838,
  /*   540 */   837,  866,  826,  755,  759,  758,  762,  763,  771,  770,
  /*   550 */   769,  780,  781,  793,  792,  824,  823,  794,  779,  773,
  /*   560 */   772,  788,  787,  786,  785,  777,  767,  799,  798,  868,
  /*   570 */   783,  867,  865,  934,  933,  932,  931,  930,  870,  967,
  /*   580 */   968,  887,  889,  886,  801,  800,  885,  869,  839,  836,
  /*   590 */   690,  691,  905,  904,  903,  693,  692,  689,  688,  863,
  /*   600 */   860,  852,  864,  861,  853,  849,  848,  834,  832,  831,
  /*   610 */   827,  835,  760,  756,  825,  765,  764,  697,  696,  694,
  /*   620 */   678,  677,  674,  667,  665,  664,  666,  662,  660,  659,
  /*   630 */   658,  657,  656,  684,  683,  682,  654,  651,  650,  646,
  /*   640 */   645,  643,
 };
 /* The next table maps tokens into fallback tokens.  If a construct

@@ -113575,71 +116110,74 @@ static const YYACTIONTYPE yy_default[] = {

 static const YYCODETYPE yyFallback[] = {
 ,  /*          $ => nothing */
 ,  /*       SEMI => nothing */
 ,  /*    EXPLAIN => ID */
 ,  /*      QUERY => ID */
 ,  /*       PLAN => ID */
 ,  /*      BEGIN => ID */
 ,  /*    EXPLAIN => ID */
 ,  /*      QUERY => ID */
 ,  /*       PLAN => ID */
 ,  /*      BEGIN => ID */
 ,  /* TRANSACTION => nothing */
 ,  /*   DEFERRED => ID */
 ,  /*  IMMEDIATE => ID */
 ,  /*  EXCLUSIVE => ID */
 ,  /*   DEFERRED => ID */
 ,  /*  IMMEDIATE => ID */
 ,  /*  EXCLUSIVE => ID */
 ,  /*     COMMIT => nothing */
 ,  /*        END => ID */
 ,  /*   ROLLBACK => ID */
 ,  /*  SAVEPOINT => ID */
 ,  /*    RELEASE => ID */
 ,  /*        END => ID */
 ,  /*   ROLLBACK => ID */
 ,  /*  SAVEPOINT => ID */
 ,  /*    RELEASE => ID */
 ,  /*         TO => nothing */
 ,  /*      TABLE => nothing */
 ,  /*     CREATE => nothing */
 ,  /*         IF => ID */
 ,  /*         IF => ID */
 ,  /*        NOT => nothing */
 ,  /*     EXISTS => nothing */
 ,  /*       TEMP => ID */
 ,  /*       TEMP => ID */
 ,  /*         LP => nothing */
 ,  /*         RP => nothing */
 ,  /*         AS => nothing */
 ,  /*    WITHOUT => ID */
 ,  /*      COMMA => nothing */
 ,  /*         ID => nothing */
 ,  /*    INDEXED => nothing */
 ,  /*      ABORT => ID */
 ,  /*     ACTION => ID */
 ,  /*      AFTER => ID */
 ,  /*    ANALYZE => ID */
 ,  /*        ASC => ID */
 ,  /*     ATTACH => ID */
 ,  /*     BEFORE => ID */
 ,  /*         BY => ID */
 ,  /*    CASCADE => ID */
 ,  /*       CAST => ID */
 ,  /*   COLUMNKW => ID */
 ,  /*   CONFLICT => ID */
 ,  /*   DATABASE => ID */
 ,  /*       DESC => ID */
 ,  /*     DETACH => ID */
 ,  /*       EACH => ID */
 ,  /*       FAIL => ID */
 ,  /*        FOR => ID */
 ,  /*     IGNORE => ID */
 ,  /*  INITIALLY => ID */
 ,  /*    INSTEAD => ID */
 ,  /*    LIKE_KW => ID */
 ,  /*      MATCH => ID */
 ,  /*         NO => ID */
 ,  /*        KEY => ID */
 ,  /*         OF => ID */
 ,  /*     OFFSET => ID */
 ,  /*     PRAGMA => ID */
 ,  /*      RAISE => ID */
 ,  /*    REPLACE => ID */
 ,  /*   RESTRICT => ID */
 ,  /*        ROW => ID */
 ,  /*    TRIGGER => ID */
 ,  /*     VACUUM => ID */
 ,  /*       VIEW => ID */
 ,  /*    VIRTUAL => ID */
 ,  /*    REINDEX => ID */
 ,  /*     RENAME => ID */
 ,  /*   CTIME_KW => ID */
 ,  /*      ABORT => ID */
 ,  /*     ACTION => ID */
 ,  /*      AFTER => ID */
 ,  /*    ANALYZE => ID */
 ,  /*        ASC => ID */
 ,  /*     ATTACH => ID */
 ,  /*     BEFORE => ID */
 ,  /*         BY => ID */
 ,  /*    CASCADE => ID */
 ,  /*       CAST => ID */
 ,  /*   COLUMNKW => ID */
 ,  /*   CONFLICT => ID */
 ,  /*   DATABASE => ID */
 ,  /*       DESC => ID */
 ,  /*     DETACH => ID */
 ,  /*       EACH => ID */
 ,  /*       FAIL => ID */
 ,  /*        FOR => ID */
 ,  /*     IGNORE => ID */
 ,  /*  INITIALLY => ID */
 ,  /*    INSTEAD => ID */
 ,  /*    LIKE_KW => ID */
 ,  /*      MATCH => ID */
 ,  /*         NO => ID */
 ,  /*        KEY => ID */
 ,  /*         OF => ID */
 ,  /*     OFFSET => ID */
 ,  /*     PRAGMA => ID */
 ,  /*      RAISE => ID */
 ,  /*  RECURSIVE => ID */
 ,  /*    REPLACE => ID */
 ,  /*   RESTRICT => ID */
 ,  /*        ROW => ID */
 ,  /*    TRIGGER => ID */
 ,  /*     VACUUM => ID */
 ,  /*       VIEW => ID */
 ,  /*    VIRTUAL => ID */
 ,  /*       WITH => ID */
 ,  /*    REINDEX => ID */
 ,  /*     RENAME => ID */
 ,  /*   CTIME_KW => ID */
 };
 #endif /* YYFALLBACK */

@@ -113724,63 +116262,64 @@ static const char *const yyTokenName[] = {

   "ROLLBACK",      "SAVEPOINT",     "RELEASE",       "TO",
   "TABLE",         "CREATE",        "IF",            "NOT",
   "EXISTS",        "TEMP",          "LP",            "RP",
   "AS",            "COMMA",         "ID",            "INDEXED",
   "ABORT",         "ACTION",        "AFTER",         "ANALYZE",
   "ASC",           "ATTACH",        "BEFORE",        "BY",
   "CASCADE",       "CAST",          "COLUMNKW",      "CONFLICT",
   "DATABASE",      "DESC",          "DETACH",        "EACH",
   "FAIL",          "FOR",           "IGNORE",        "INITIALLY",
   "INSTEAD",       "LIKE_KW",       "MATCH",         "NO",
   "KEY",           "OF",            "OFFSET",        "PRAGMA",
   "RAISE",         "REPLACE",       "RESTRICT",      "ROW",
   "TRIGGER",       "VACUUM",        "VIEW",          "VIRTUAL",
   "REINDEX",       "RENAME",        "CTIME_KW",      "ANY",
   "OR",            "AND",           "IS",            "BETWEEN",
   "IN",            "ISNULL",        "NOTNULL",       "NE",
   "EQ",            "GT",            "LE",            "LT",
   "GE",            "ESCAPE",        "BITAND",        "BITOR",
   "LSHIFT",        "RSHIFT",        "PLUS",          "MINUS",
   "STAR",          "SLASH",         "REM",           "CONCAT",
   "COLLATE",       "BITNOT",        "STRING",        "JOIN_KW",
   "CONSTRAINT",    "DEFAULT",       "NULL",          "PRIMARY",
   "UNIQUE",        "CHECK",         "REFERENCES",    "AUTOINCR",
   "ON",            "INSERT",        "DELETE",        "UPDATE",
   "SET",           "DEFERRABLE",    "FOREIGN",       "DROP",
   "UNION",         "ALL",           "EXCEPT",        "INTERSECT",
   "SELECT",        "DISTINCT",      "DOT",           "FROM",
   "AS",            "WITHOUT",       "COMMA",         "ID",
   "INDEXED",       "ABORT",         "ACTION",        "AFTER",
   "ANALYZE",       "ASC",           "ATTACH",        "BEFORE",
   "BY",            "CASCADE",       "CAST",          "COLUMNKW",
   "CONFLICT",      "DATABASE",      "DESC",          "DETACH",
   "EACH",          "FAIL",          "FOR",           "IGNORE",
   "INITIALLY",     "INSTEAD",       "LIKE_KW",       "MATCH",
   "NO",            "KEY",           "OF",            "OFFSET",
   "PRAGMA",        "RAISE",         "RECURSIVE",     "REPLACE",
   "RESTRICT",      "ROW",           "TRIGGER",       "VACUUM",
   "VIEW",          "VIRTUAL",       "WITH",          "REINDEX",
   "RENAME",        "CTIME_KW",      "ANY",           "OR",
   "AND",           "IS",            "BETWEEN",       "IN",
   "ISNULL",        "NOTNULL",       "NE",            "EQ",
   "GT",            "LE",            "LT",            "GE",
   "ESCAPE",        "BITAND",        "BITOR",         "LSHIFT",
   "RSHIFT",        "PLUS",          "MINUS",         "STAR",
   "SLASH",         "REM",           "CONCAT",        "COLLATE",
   "BITNOT",        "STRING",        "JOIN_KW",       "CONSTRAINT",
   "DEFAULT",       "NULL",          "PRIMARY",       "UNIQUE",
   "CHECK",         "REFERENCES",    "AUTOINCR",      "ON",
   "INSERT",        "DELETE",        "UPDATE",        "SET",
   "DEFERRABLE",    "FOREIGN",       "DROP",          "UNION",
   "ALL",           "EXCEPT",        "INTERSECT",     "SELECT",
   "VALUES",        "DISTINCT",      "DOT",           "FROM",
   "JOIN",          "USING",         "ORDER",         "GROUP",
   "HAVING",        "LIMIT",         "WHERE",         "INTO",
   "VALUES",        "INTEGER",       "FLOAT",         "BLOB",
   "REGISTER",      "VARIABLE",      "CASE",          "WHEN",
   "THEN",          "ELSE",          "INDEX",         "ALTER",
   "ADD",           "error",         "input",         "cmdlist",
   "ecmd",          "explain",       "cmdx",          "cmd",
   "transtype",     "trans_opt",     "nm",            "savepoint_opt",
   "create_table",  "create_table_args",  "createkw",      "temp",
   "ifnotexists",   "dbnm",          "columnlist",    "conslist_opt",
   "select",        "column",        "columnid",      "type",
   "carglist",      "id",            "ids",           "typetoken",
   "typename",      "signed",        "plus_num",      "minus_num",
   "ccons",         "term",          "expr",          "onconf",
   "sortorder",     "autoinc",       "idxlist_opt",   "refargs",
   "defer_subclause",  "refarg",        "refact",        "init_deferred_pred_opt",
   "conslist",      "tconscomma",    "tcons",         "idxlist",
   "defer_subclause_opt",  "orconf",        "resolvetype",   "raisetype",
   "ifexists",      "fullname",      "oneselect",     "multiselect_op",
   "distinct",      "selcollist",    "from",          "where_opt",
   "groupby_opt",   "having_opt",    "orderby_opt",   "limit_opt",
   "sclp",          "as",            "seltablist",    "stl_prefix",
   "joinop",        "indexed_opt",   "on_opt",        "using_opt",
   "joinop2",       "inscollist",    "sortlist",      "nexprlist",
   "setlist",       "insert_cmd",    "inscollist_opt",  "valuelist",
   "exprlist",      "likeop",        "between_op",    "in_op",
   "case_operand",  "case_exprlist",  "case_else",     "uniqueflag",
   "collate",       "nmnum",         "number",        "trigger_decl",
   "trigger_cmd_list",  "trigger_time",  "trigger_event",  "foreach_clause",
   "when_clause",   "trigger_cmd",   "trnm",          "tridxby",
   "database_kw_opt",  "key_opt",       "add_column_fullname",  "kwcolumn_opt",
   "create_vtab",   "vtabarglist",   "vtabarg",       "vtabargtoken",
   "lp",            "anylist",
   "INTEGER",       "FLOAT",         "BLOB",          "VARIABLE",
   "CASE",          "WHEN",          "THEN",          "ELSE",
   "INDEX",         "ALTER",         "ADD",           "error",
   "input",         "cmdlist",       "ecmd",          "explain",
   "cmdx",          "cmd",           "transtype",     "trans_opt",
   "nm",            "savepoint_opt",  "create_table",  "create_table_args",
   "createkw",      "temp",          "ifnotexists",   "dbnm",
   "columnlist",    "conslist_opt",  "table_options",  "select",
   "column",        "columnid",      "type",          "carglist",
   "typetoken",     "typename",      "signed",        "plus_num",
   "minus_num",     "ccons",         "term",          "expr",
   "onconf",        "sortorder",     "autoinc",       "idxlist_opt",
   "refargs",       "defer_subclause",  "refarg",        "refact",
   "init_deferred_pred_opt",  "conslist",      "tconscomma",    "tcons",
   "idxlist",       "defer_subclause_opt",  "orconf",        "resolvetype",
   "raisetype",     "ifexists",      "fullname",      "selectnowith",
   "oneselect",     "with",          "multiselect_op",  "distinct",
   "selcollist",    "from",          "where_opt",     "groupby_opt",
   "having_opt",    "orderby_opt",   "limit_opt",     "values",
   "nexprlist",     "exprlist",      "sclp",          "as",
   "seltablist",    "stl_prefix",    "joinop",        "indexed_opt",
   "on_opt",        "using_opt",     "joinop2",       "idlist",
   "sortlist",      "setlist",       "insert_cmd",    "inscollist_opt",
   "likeop",        "between_op",    "in_op",         "case_operand",
   "case_exprlist",  "case_else",     "uniqueflag",    "collate",
   "nmnum",         "trigger_decl",  "trigger_cmd_list",  "trigger_time",
   "trigger_event",  "foreach_clause",  "when_clause",   "trigger_cmd",
   "trnm",          "tridxby",       "database_kw_opt",  "key_opt",
   "add_column_fullname",  "kwcolumn_opt",  "create_vtab",   "vtabarglist",
   "vtabarg",       "vtabargtoken",  "lp",            "anylist",
   "wqlist",
 };
 #endif /* NDEBUG */

@@ -113820,301 +116359,301 @@ static const char *const yyRuleName[] = {

  /*  29 */ "ifnotexists ::= IF NOT EXISTS",
  /*  30 */ "temp ::= TEMP",
  /*  31 */ "temp ::=",
  /*  32 */ "create_table_args ::= LP columnlist conslist_opt RP",
  /*  32 */ "create_table_args ::= LP columnlist conslist_opt RP table_options",
  /*  33 */ "create_table_args ::= AS select",
  /*  34 */ "columnlist ::= columnlist COMMA column",
  /*  35 */ "columnlist ::= column",
  /*  36 */ "column ::= columnid type carglist",
  /*  37 */ "columnid ::= nm",
  /*  38 */ "id ::= ID",
  /*  39 */ "id ::= INDEXED",
  /*  40 */ "ids ::= ID|STRING",
  /*  41 */ "nm ::= id",
  /*  42 */ "nm ::= STRING",
  /*  43 */ "nm ::= JOIN_KW",
  /*  44 */ "type ::=",
  /*  45 */ "type ::= typetoken",
  /*  46 */ "typetoken ::= typename",
  /*  47 */ "typetoken ::= typename LP signed RP",
  /*  48 */ "typetoken ::= typename LP signed COMMA signed RP",
  /*  49 */ "typename ::= ids",
  /*  50 */ "typename ::= typename ids",
  /*  51 */ "signed ::= plus_num",
  /*  52 */ "signed ::= minus_num",
  /*  53 */ "carglist ::= carglist ccons",
  /*  54 */ "carglist ::=",
  /*  55 */ "ccons ::= CONSTRAINT nm",
  /*  56 */ "ccons ::= DEFAULT term",
  /*  57 */ "ccons ::= DEFAULT LP expr RP",
  /*  58 */ "ccons ::= DEFAULT PLUS term",
  /*  59 */ "ccons ::= DEFAULT MINUS term",
  /*  60 */ "ccons ::= DEFAULT id",
  /*  61 */ "ccons ::= NULL onconf",
  /*  62 */ "ccons ::= NOT NULL onconf",
  /*  63 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc",
  /*  64 */ "ccons ::= UNIQUE onconf",
  /*  65 */ "ccons ::= CHECK LP expr RP",
  /*  66 */ "ccons ::= REFERENCES nm idxlist_opt refargs",
  /*  67 */ "ccons ::= defer_subclause",
  /*  68 */ "ccons ::= COLLATE ids",
  /*  69 */ "autoinc ::=",
  /*  70 */ "autoinc ::= AUTOINCR",
  /*  71 */ "refargs ::=",
  /*  72 */ "refargs ::= refargs refarg",
  /*  73 */ "refarg ::= MATCH nm",
  /*  74 */ "refarg ::= ON INSERT refact",
  /*  75 */ "refarg ::= ON DELETE refact",
  /*  76 */ "refarg ::= ON UPDATE refact",
  /*  77 */ "refact ::= SET NULL",
  /*  78 */ "refact ::= SET DEFAULT",
  /*  79 */ "refact ::= CASCADE",
  /*  80 */ "refact ::= RESTRICT",
  /*  81 */ "refact ::= NO ACTION",
  /*  82 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt",
  /*  83 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt",
  /*  84 */ "init_deferred_pred_opt ::=",
  /*  85 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED",
  /*  86 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE",
  /*  87 */ "conslist_opt ::=",
  /*  88 */ "conslist_opt ::= COMMA conslist",
  /*  89 */ "conslist ::= conslist tconscomma tcons",
  /*  90 */ "conslist ::= tcons",
  /*  91 */ "tconscomma ::= COMMA",
  /*  92 */ "tconscomma ::=",
  /*  93 */ "tcons ::= CONSTRAINT nm",
  /*  94 */ "tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf",
  /*  95 */ "tcons ::= UNIQUE LP idxlist RP onconf",
  /*  96 */ "tcons ::= CHECK LP expr RP onconf",
  /*  97 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt",
  /*  98 */ "defer_subclause_opt ::=",
  /*  99 */ "defer_subclause_opt ::= defer_subclause",
  /* 100 */ "onconf ::=",
  /* 101 */ "onconf ::= ON CONFLICT resolvetype",
  /* 102 */ "orconf ::=",
  /* 103 */ "orconf ::= OR resolvetype",
  /* 104 */ "resolvetype ::= raisetype",
  /* 105 */ "resolvetype ::= IGNORE",
  /* 106 */ "resolvetype ::= REPLACE",
  /* 107 */ "cmd ::= DROP TABLE ifexists fullname",
  /* 108 */ "ifexists ::= IF EXISTS",
  /* 109 */ "ifexists ::=",
  /* 110 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select",
  /* 111 */ "cmd ::= DROP VIEW ifexists fullname",
  /* 112 */ "cmd ::= select",
  /* 113 */ "select ::= oneselect",
  /* 114 */ "select ::= select multiselect_op oneselect",
  /*  34 */ "table_options ::=",
  /*  35 */ "table_options ::= WITHOUT nm",
  /*  36 */ "columnlist ::= columnlist COMMA column",
  /*  37 */ "columnlist ::= column",
  /*  38 */ "column ::= columnid type carglist",
  /*  39 */ "columnid ::= nm",
  /*  40 */ "nm ::= ID|INDEXED",
  /*  41 */ "nm ::= STRING",
  /*  42 */ "nm ::= JOIN_KW",
  /*  43 */ "type ::=",
  /*  44 */ "type ::= typetoken",
  /*  45 */ "typetoken ::= typename",
  /*  46 */ "typetoken ::= typename LP signed RP",
  /*  47 */ "typetoken ::= typename LP signed COMMA signed RP",
  /*  48 */ "typename ::= ID|STRING",
  /*  49 */ "typename ::= typename ID|STRING",
  /*  50 */ "signed ::= plus_num",
  /*  51 */ "signed ::= minus_num",
  /*  52 */ "carglist ::= carglist ccons",
  /*  53 */ "carglist ::=",
  /*  54 */ "ccons ::= CONSTRAINT nm",
  /*  55 */ "ccons ::= DEFAULT term",
  /*  56 */ "ccons ::= DEFAULT LP expr RP",
  /*  57 */ "ccons ::= DEFAULT PLUS term",
  /*  58 */ "ccons ::= DEFAULT MINUS term",
  /*  59 */ "ccons ::= DEFAULT ID|INDEXED",
  /*  60 */ "ccons ::= NULL onconf",
  /*  61 */ "ccons ::= NOT NULL onconf",
  /*  62 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc",
  /*  63 */ "ccons ::= UNIQUE onconf",
  /*  64 */ "ccons ::= CHECK LP expr RP",
  /*  65 */ "ccons ::= REFERENCES nm idxlist_opt refargs",
  /*  66 */ "ccons ::= defer_subclause",
  /*  67 */ "ccons ::= COLLATE ID|STRING",
  /*  68 */ "autoinc ::=",
  /*  69 */ "autoinc ::= AUTOINCR",
  /*  70 */ "refargs ::=",
  /*  71 */ "refargs ::= refargs refarg",
  /*  72 */ "refarg ::= MATCH nm",
  /*  73 */ "refarg ::= ON INSERT refact",
  /*  74 */ "refarg ::= ON DELETE refact",
  /*  75 */ "refarg ::= ON UPDATE refact",
  /*  76 */ "refact ::= SET NULL",
  /*  77 */ "refact ::= SET DEFAULT",
  /*  78 */ "refact ::= CASCADE",
  /*  79 */ "refact ::= RESTRICT",
  /*  80 */ "refact ::= NO ACTION",
  /*  81 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt",
  /*  82 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt",
  /*  83 */ "init_deferred_pred_opt ::=",
  /*  84 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED",
  /*  85 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE",
  /*  86 */ "conslist_opt ::=",
  /*  87 */ "conslist_opt ::= COMMA conslist",
  /*  88 */ "conslist ::= conslist tconscomma tcons",
  /*  89 */ "conslist ::= tcons",
  /*  90 */ "tconscomma ::= COMMA",
  /*  91 */ "tconscomma ::=",
  /*  92 */ "tcons ::= CONSTRAINT nm",
  /*  93 */ "tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf",
  /*  94 */ "tcons ::= UNIQUE LP idxlist RP onconf",
  /*  95 */ "tcons ::= CHECK LP expr RP onconf",
  /*  96 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt",
  /*  97 */ "defer_subclause_opt ::=",
  /*  98 */ "defer_subclause_opt ::= defer_subclause",
  /*  99 */ "onconf ::=",
  /* 100 */ "onconf ::= ON CONFLICT resolvetype",
  /* 101 */ "orconf ::=",
  /* 102 */ "orconf ::= OR resolvetype",
  /* 103 */ "resolvetype ::= raisetype",
  /* 104 */ "resolvetype ::= IGNORE",
  /* 105 */ "resolvetype ::= REPLACE",
  /* 106 */ "cmd ::= DROP TABLE ifexists fullname",
  /* 107 */ "ifexists ::= IF EXISTS",
  /* 108 */ "ifexists ::=",
  /* 109 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select",
  /* 110 */ "cmd ::= DROP VIEW ifexists fullname",
  /* 111 */ "cmd ::= select",
  /* 112 */ "select ::= with selectnowith",
  /* 113 */ "selectnowith ::= oneselect",
  /* 114 */ "selectnowith ::= selectnowith multiselect_op oneselect",
  /* 115 */ "multiselect_op ::= UNION",
  /* 116 */ "multiselect_op ::= UNION ALL",
  /* 117 */ "multiselect_op ::= EXCEPT|INTERSECT",
  /* 118 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
  /* 119 */ "distinct ::= DISTINCT",
  /* 120 */ "distinct ::= ALL",
  /* 121 */ "distinct ::=",
  /* 122 */ "sclp ::= selcollist COMMA",
  /* 123 */ "sclp ::=",
  /* 124 */ "selcollist ::= sclp expr as",
  /* 125 */ "selcollist ::= sclp STAR",
  /* 126 */ "selcollist ::= sclp nm DOT STAR",
  /* 127 */ "as ::= AS nm",
  /* 128 */ "as ::= ids",
  /* 129 */ "as ::=",
  /* 130 */ "from ::=",
  /* 131 */ "from ::= FROM seltablist",
  /* 132 */ "stl_prefix ::= seltablist joinop",
  /* 133 */ "stl_prefix ::=",
  /* 134 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt",
  /* 135 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt",
  /* 136 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt",
  /* 137 */ "dbnm ::=",
  /* 138 */ "dbnm ::= DOT nm",
  /* 139 */ "fullname ::= nm dbnm",
  /* 140 */ "joinop ::= COMMA|JOIN",
  /* 141 */ "joinop ::= JOIN_KW JOIN",
  /* 142 */ "joinop ::= JOIN_KW nm JOIN",
  /* 143 */ "joinop ::= JOIN_KW nm nm JOIN",
  /* 144 */ "on_opt ::= ON expr",
  /* 145 */ "on_opt ::=",
  /* 146 */ "indexed_opt ::=",
  /* 147 */ "indexed_opt ::= INDEXED BY nm",
  /* 148 */ "indexed_opt ::= NOT INDEXED",
  /* 149 */ "using_opt ::= USING LP inscollist RP",
  /* 150 */ "using_opt ::=",
  /* 151 */ "orderby_opt ::=",
  /* 152 */ "orderby_opt ::= ORDER BY sortlist",
  /* 153 */ "sortlist ::= sortlist COMMA expr sortorder",
  /* 154 */ "sortlist ::= expr sortorder",
  /* 155 */ "sortorder ::= ASC",
  /* 156 */ "sortorder ::= DESC",
  /* 157 */ "sortorder ::=",
  /* 158 */ "groupby_opt ::=",
  /* 159 */ "groupby_opt ::= GROUP BY nexprlist",
  /* 160 */ "having_opt ::=",
  /* 161 */ "having_opt ::= HAVING expr",
  /* 162 */ "limit_opt ::=",
  /* 163 */ "limit_opt ::= LIMIT expr",
  /* 164 */ "limit_opt ::= LIMIT expr OFFSET expr",
  /* 165 */ "limit_opt ::= LIMIT expr COMMA expr",
  /* 166 */ "cmd ::= DELETE FROM fullname indexed_opt where_opt",
  /* 167 */ "where_opt ::=",
  /* 168 */ "where_opt ::= WHERE expr",
  /* 169 */ "cmd ::= UPDATE orconf fullname indexed_opt SET setlist where_opt",
  /* 170 */ "setlist ::= setlist COMMA nm EQ expr",
  /* 171 */ "setlist ::= nm EQ expr",
  /* 172 */ "cmd ::= insert_cmd INTO fullname inscollist_opt valuelist",
  /* 173 */ "cmd ::= insert_cmd INTO fullname inscollist_opt select",
  /* 174 */ "cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES",
  /* 175 */ "insert_cmd ::= INSERT orconf",
  /* 176 */ "insert_cmd ::= REPLACE",
  /* 177 */ "valuelist ::= VALUES LP nexprlist RP",
  /* 178 */ "valuelist ::= valuelist COMMA LP exprlist RP",
  /* 119 */ "oneselect ::= values",
  /* 120 */ "values ::= VALUES LP nexprlist RP",
  /* 121 */ "values ::= values COMMA LP exprlist RP",
  /* 122 */ "distinct ::= DISTINCT",
  /* 123 */ "distinct ::= ALL",
  /* 124 */ "distinct ::=",
  /* 125 */ "sclp ::= selcollist COMMA",
  /* 126 */ "sclp ::=",
  /* 127 */ "selcollist ::= sclp expr as",
  /* 128 */ "selcollist ::= sclp STAR",
  /* 129 */ "selcollist ::= sclp nm DOT STAR",
  /* 130 */ "as ::= AS nm",
  /* 131 */ "as ::= ID|STRING",
  /* 132 */ "as ::=",
  /* 133 */ "from ::=",
  /* 134 */ "from ::= FROM seltablist",
  /* 135 */ "stl_prefix ::= seltablist joinop",
  /* 136 */ "stl_prefix ::=",
  /* 137 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt",
  /* 138 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt",
  /* 139 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt",
  /* 140 */ "dbnm ::=",
  /* 141 */ "dbnm ::= DOT nm",
  /* 142 */ "fullname ::= nm dbnm",
  /* 143 */ "joinop ::= COMMA|JOIN",
  /* 144 */ "joinop ::= JOIN_KW JOIN",
  /* 145 */ "joinop ::= JOIN_KW nm JOIN",
  /* 146 */ "joinop ::= JOIN_KW nm nm JOIN",
  /* 147 */ "on_opt ::= ON expr",
  /* 148 */ "on_opt ::=",
  /* 149 */ "indexed_opt ::=",
  /* 150 */ "indexed_opt ::= INDEXED BY nm",
  /* 151 */ "indexed_opt ::= NOT INDEXED",
  /* 152 */ "using_opt ::= USING LP idlist RP",
  /* 153 */ "using_opt ::=",
  /* 154 */ "orderby_opt ::=",
  /* 155 */ "orderby_opt ::= ORDER BY sortlist",
  /* 156 */ "sortlist ::= sortlist COMMA expr sortorder",
  /* 157 */ "sortlist ::= expr sortorder",
  /* 158 */ "sortorder ::= ASC",
  /* 159 */ "sortorder ::= DESC",
  /* 160 */ "sortorder ::=",
  /* 161 */ "groupby_opt ::=",
  /* 162 */ "groupby_opt ::= GROUP BY nexprlist",
  /* 163 */ "having_opt ::=",
  /* 164 */ "having_opt ::= HAVING expr",
  /* 165 */ "limit_opt ::=",
  /* 166 */ "limit_opt ::= LIMIT expr",
  /* 167 */ "limit_opt ::= LIMIT expr OFFSET expr",
  /* 168 */ "limit_opt ::= LIMIT expr COMMA expr",
  /* 169 */ "cmd ::= with DELETE FROM fullname indexed_opt where_opt",
  /* 170 */ "where_opt ::=",
  /* 171 */ "where_opt ::= WHERE expr",
  /* 172 */ "cmd ::= with UPDATE orconf fullname indexed_opt SET setlist where_opt",
  /* 173 */ "setlist ::= setlist COMMA nm EQ expr",
  /* 174 */ "setlist ::= nm EQ expr",
  /* 175 */ "cmd ::= with insert_cmd INTO fullname inscollist_opt select",
  /* 176 */ "cmd ::= with insert_cmd INTO fullname inscollist_opt DEFAULT VALUES",
  /* 177 */ "insert_cmd ::= INSERT orconf",
  /* 178 */ "insert_cmd ::= REPLACE",
  /* 179 */ "inscollist_opt ::=",
  /* 180 */ "inscollist_opt ::= LP inscollist RP",
  /* 181 */ "inscollist ::= inscollist COMMA nm",
  /* 182 */ "inscollist ::= nm",
  /* 180 */ "inscollist_opt ::= LP idlist RP",
  /* 181 */ "idlist ::= idlist COMMA nm",
  /* 182 */ "idlist ::= nm",
  /* 183 */ "expr ::= term",
  /* 184 */ "expr ::= LP expr RP",
  /* 185 */ "term ::= NULL",
  /* 186 */ "expr ::= id",
  /* 186 */ "expr ::= ID|INDEXED",
  /* 187 */ "expr ::= JOIN_KW",
  /* 188 */ "expr ::= nm DOT nm",
  /* 189 */ "expr ::= nm DOT nm DOT nm",
  /* 190 */ "term ::= INTEGER|FLOAT|BLOB",
  /* 191 */ "term ::= STRING",
  /* 192 */ "expr ::= REGISTER",
  /* 193 */ "expr ::= VARIABLE",
  /* 194 */ "expr ::= expr COLLATE ids",
  /* 195 */ "expr ::= CAST LP expr AS typetoken RP",
  /* 196 */ "expr ::= ID LP distinct exprlist RP",
  /* 197 */ "expr ::= ID LP STAR RP",
  /* 198 */ "term ::= CTIME_KW",
  /* 199 */ "expr ::= expr AND expr",
  /* 200 */ "expr ::= expr OR expr",
  /* 201 */ "expr ::= expr LT|GT|GE|LE expr",
  /* 202 */ "expr ::= expr EQ|NE expr",
  /* 203 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
  /* 204 */ "expr ::= expr PLUS|MINUS expr",
  /* 205 */ "expr ::= expr STAR|SLASH|REM expr",
  /* 206 */ "expr ::= expr CONCAT expr",
  /* 207 */ "likeop ::= LIKE_KW",
  /* 208 */ "likeop ::= NOT LIKE_KW",
  /* 209 */ "likeop ::= MATCH",
  /* 210 */ "likeop ::= NOT MATCH",
  /* 211 */ "expr ::= expr likeop expr",
  /* 212 */ "expr ::= expr likeop expr ESCAPE expr",
  /* 213 */ "expr ::= expr ISNULL|NOTNULL",
  /* 214 */ "expr ::= expr NOT NULL",
  /* 215 */ "expr ::= expr IS expr",
  /* 216 */ "expr ::= expr IS NOT expr",
  /* 217 */ "expr ::= NOT expr",
  /* 218 */ "expr ::= BITNOT expr",
  /* 219 */ "expr ::= MINUS expr",
  /* 220 */ "expr ::= PLUS expr",
  /* 221 */ "between_op ::= BETWEEN",
  /* 222 */ "between_op ::= NOT BETWEEN",
  /* 223 */ "expr ::= expr between_op expr AND expr",
  /* 224 */ "in_op ::= IN",
  /* 225 */ "in_op ::= NOT IN",
  /* 226 */ "expr ::= expr in_op LP exprlist RP",
  /* 227 */ "expr ::= LP select RP",
  /* 228 */ "expr ::= expr in_op LP select RP",
  /* 229 */ "expr ::= expr in_op nm dbnm",
  /* 230 */ "expr ::= EXISTS LP select RP",
  /* 231 */ "expr ::= CASE case_operand case_exprlist case_else END",
  /* 232 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
  /* 233 */ "case_exprlist ::= WHEN expr THEN expr",
  /* 234 */ "case_else ::= ELSE expr",
  /* 235 */ "case_else ::=",
  /* 236 */ "case_operand ::= expr",
  /* 237 */ "case_operand ::=",
  /* 238 */ "exprlist ::= nexprlist",
  /* 239 */ "exprlist ::=",
  /* 240 */ "nexprlist ::= nexprlist COMMA expr",
  /* 241 */ "nexprlist ::= expr",
  /* 242 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP where_opt",
  /* 243 */ "uniqueflag ::= UNIQUE",
  /* 244 */ "uniqueflag ::=",
  /* 245 */ "idxlist_opt ::=",
  /* 246 */ "idxlist_opt ::= LP idxlist RP",
  /* 247 */ "idxlist ::= idxlist COMMA nm collate sortorder",
  /* 248 */ "idxlist ::= nm collate sortorder",
  /* 249 */ "collate ::=",
  /* 250 */ "collate ::= COLLATE ids",
  /* 251 */ "cmd ::= DROP INDEX ifexists fullname",
  /* 252 */ "cmd ::= VACUUM",
  /* 253 */ "cmd ::= VACUUM nm",
  /* 254 */ "cmd ::= PRAGMA nm dbnm",
  /* 255 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
  /* 256 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
  /* 257 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
  /* 258 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
  /* 259 */ "nmnum ::= plus_num",
  /* 260 */ "nmnum ::= nm",
  /* 261 */ "nmnum ::= ON",
  /* 262 */ "nmnum ::= DELETE",
  /* 263 */ "nmnum ::= DEFAULT",
  /* 264 */ "plus_num ::= PLUS number",
  /* 265 */ "plus_num ::= number",
  /* 266 */ "minus_num ::= MINUS number",
  /* 267 */ "number ::= INTEGER|FLOAT",
  /* 268 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
  /* 269 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
  /* 270 */ "trigger_time ::= BEFORE",
  /* 271 */ "trigger_time ::= AFTER",
  /* 272 */ "trigger_time ::= INSTEAD OF",
  /* 273 */ "trigger_time ::=",
  /* 274 */ "trigger_event ::= DELETE|INSERT",
  /* 275 */ "trigger_event ::= UPDATE",
  /* 276 */ "trigger_event ::= UPDATE OF inscollist",
  /* 277 */ "foreach_clause ::=",
  /* 278 */ "foreach_clause ::= FOR EACH ROW",
  /* 279 */ "when_clause ::=",
  /* 280 */ "when_clause ::= WHEN expr",
  /* 281 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
  /* 282 */ "trigger_cmd_list ::= trigger_cmd SEMI",
  /* 283 */ "trnm ::= nm",
  /* 284 */ "trnm ::= nm DOT nm",
  /* 285 */ "tridxby ::=",
  /* 286 */ "tridxby ::= INDEXED BY nm",
  /* 287 */ "tridxby ::= NOT INDEXED",
  /* 288 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
  /* 289 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt valuelist",
  /* 290 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select",
  /* 291 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
  /* 292 */ "trigger_cmd ::= select",
  /* 293 */ "expr ::= RAISE LP IGNORE RP",
  /* 294 */ "expr ::= RAISE LP raisetype COMMA nm RP",
  /* 295 */ "raisetype ::= ROLLBACK",
  /* 296 */ "raisetype ::= ABORT",
  /* 297 */ "raisetype ::= FAIL",
  /* 298 */ "cmd ::= DROP TRIGGER ifexists fullname",
  /* 299 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
  /* 300 */ "cmd ::= DETACH database_kw_opt expr",
  /* 301 */ "key_opt ::=",
  /* 302 */ "key_opt ::= KEY expr",
  /* 303 */ "database_kw_opt ::= DATABASE",
  /* 304 */ "database_kw_opt ::=",
  /* 305 */ "cmd ::= REINDEX",
  /* 306 */ "cmd ::= REINDEX nm dbnm",
  /* 307 */ "cmd ::= ANALYZE",
  /* 308 */ "cmd ::= ANALYZE nm dbnm",
  /* 309 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
  /* 310 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
  /* 311 */ "add_column_fullname ::= fullname",
  /* 312 */ "kwcolumn_opt ::=",
  /* 313 */ "kwcolumn_opt ::= COLUMNKW",
  /* 314 */ "cmd ::= create_vtab",
  /* 315 */ "cmd ::= create_vtab LP vtabarglist RP",
  /* 316 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
  /* 317 */ "vtabarglist ::= vtabarg",
  /* 318 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
  /* 319 */ "vtabarg ::=",
  /* 320 */ "vtabarg ::= vtabarg vtabargtoken",
  /* 321 */ "vtabargtoken ::= ANY",
  /* 322 */ "vtabargtoken ::= lp anylist RP",
  /* 323 */ "lp ::= LP",
  /* 324 */ "anylist ::=",
  /* 325 */ "anylist ::= anylist LP anylist RP",
  /* 326 */ "anylist ::= anylist ANY",
  /* 192 */ "expr ::= VARIABLE",
  /* 193 */ "expr ::= expr COLLATE ID|STRING",
  /* 194 */ "expr ::= CAST LP expr AS typetoken RP",
  /* 195 */ "expr ::= ID|INDEXED LP distinct exprlist RP",
  /* 196 */ "expr ::= ID|INDEXED LP STAR RP",
  /* 197 */ "term ::= CTIME_KW",
  /* 198 */ "expr ::= expr AND expr",
  /* 199 */ "expr ::= expr OR expr",
  /* 200 */ "expr ::= expr LT|GT|GE|LE expr",
  /* 201 */ "expr ::= expr EQ|NE expr",
  /* 202 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
  /* 203 */ "expr ::= expr PLUS|MINUS expr",
  /* 204 */ "expr ::= expr STAR|SLASH|REM expr",
  /* 205 */ "expr ::= expr CONCAT expr",
  /* 206 */ "likeop ::= LIKE_KW|MATCH",
  /* 207 */ "likeop ::= NOT LIKE_KW|MATCH",
  /* 208 */ "expr ::= expr likeop expr",
  /* 209 */ "expr ::= expr likeop expr ESCAPE expr",
  /* 210 */ "expr ::= expr ISNULL|NOTNULL",
  /* 211 */ "expr ::= expr NOT NULL",
  /* 212 */ "expr ::= expr IS expr",
  /* 213 */ "expr ::= expr IS NOT expr",
  /* 214 */ "expr ::= NOT expr",
  /* 215 */ "expr ::= BITNOT expr",
  /* 216 */ "expr ::= MINUS expr",
  /* 217 */ "expr ::= PLUS expr",
  /* 218 */ "between_op ::= BETWEEN",
  /* 219 */ "between_op ::= NOT BETWEEN",
  /* 220 */ "expr ::= expr between_op expr AND expr",
  /* 221 */ "in_op ::= IN",
  /* 222 */ "in_op ::= NOT IN",
  /* 223 */ "expr ::= expr in_op LP exprlist RP",
  /* 224 */ "expr ::= LP select RP",
  /* 225 */ "expr ::= expr in_op LP select RP",
  /* 226 */ "expr ::= expr in_op nm dbnm",
  /* 227 */ "expr ::= EXISTS LP select RP",
  /* 228 */ "expr ::= CASE case_operand case_exprlist case_else END",
  /* 229 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
  /* 230 */ "case_exprlist ::= WHEN expr THEN expr",
  /* 231 */ "case_else ::= ELSE expr",
  /* 232 */ "case_else ::=",
  /* 233 */ "case_operand ::= expr",
  /* 234 */ "case_operand ::=",
  /* 235 */ "exprlist ::= nexprlist",
  /* 236 */ "exprlist ::=",
  /* 237 */ "nexprlist ::= nexprlist COMMA expr",
  /* 238 */ "nexprlist ::= expr",
  /* 239 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP where_opt",
  /* 240 */ "uniqueflag ::= UNIQUE",
  /* 241 */ "uniqueflag ::=",
  /* 242 */ "idxlist_opt ::=",
  /* 243 */ "idxlist_opt ::= LP idxlist RP",
  /* 244 */ "idxlist ::= idxlist COMMA nm collate sortorder",
  /* 245 */ "idxlist ::= nm collate sortorder",
  /* 246 */ "collate ::=",
  /* 247 */ "collate ::= COLLATE ID|STRING",
  /* 248 */ "cmd ::= DROP INDEX ifexists fullname",
  /* 249 */ "cmd ::= VACUUM",
  /* 250 */ "cmd ::= VACUUM nm",
  /* 251 */ "cmd ::= PRAGMA nm dbnm",
  /* 252 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
  /* 253 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
  /* 254 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
  /* 255 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
  /* 256 */ "nmnum ::= plus_num",
  /* 257 */ "nmnum ::= nm",
  /* 258 */ "nmnum ::= ON",
  /* 259 */ "nmnum ::= DELETE",
  /* 260 */ "nmnum ::= DEFAULT",
  /* 261 */ "plus_num ::= PLUS INTEGER|FLOAT",
  /* 262 */ "plus_num ::= INTEGER|FLOAT",
  /* 263 */ "minus_num ::= MINUS INTEGER|FLOAT",
  /* 264 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
  /* 265 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
  /* 266 */ "trigger_time ::= BEFORE",
  /* 267 */ "trigger_time ::= AFTER",
  /* 268 */ "trigger_time ::= INSTEAD OF",
  /* 269 */ "trigger_time ::=",
  /* 270 */ "trigger_event ::= DELETE|INSERT",
  /* 271 */ "trigger_event ::= UPDATE",
  /* 272 */ "trigger_event ::= UPDATE OF idlist",
  /* 273 */ "foreach_clause ::=",
  /* 274 */ "foreach_clause ::= FOR EACH ROW",
  /* 275 */ "when_clause ::=",
  /* 276 */ "when_clause ::= WHEN expr",
  /* 277 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
  /* 278 */ "trigger_cmd_list ::= trigger_cmd SEMI",
  /* 279 */ "trnm ::= nm",
  /* 280 */ "trnm ::= nm DOT nm",
  /* 281 */ "tridxby ::=",
  /* 282 */ "tridxby ::= INDEXED BY nm",
  /* 283 */ "tridxby ::= NOT INDEXED",
  /* 284 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
  /* 285 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select",
  /* 286 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
  /* 287 */ "trigger_cmd ::= select",
  /* 288 */ "expr ::= RAISE LP IGNORE RP",
  /* 289 */ "expr ::= RAISE LP raisetype COMMA nm RP",
  /* 290 */ "raisetype ::= ROLLBACK",
  /* 291 */ "raisetype ::= ABORT",
  /* 292 */ "raisetype ::= FAIL",
  /* 293 */ "cmd ::= DROP TRIGGER ifexists fullname",
  /* 294 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
  /* 295 */ "cmd ::= DETACH database_kw_opt expr",
  /* 296 */ "key_opt ::=",
  /* 297 */ "key_opt ::= KEY expr",
  /* 298 */ "database_kw_opt ::= DATABASE",
  /* 299 */ "database_kw_opt ::=",
  /* 300 */ "cmd ::= REINDEX",
  /* 301 */ "cmd ::= REINDEX nm dbnm",
  /* 302 */ "cmd ::= ANALYZE",
  /* 303 */ "cmd ::= ANALYZE nm dbnm",
  /* 304 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
  /* 305 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
  /* 306 */ "add_column_fullname ::= fullname",
  /* 307 */ "kwcolumn_opt ::=",
  /* 308 */ "kwcolumn_opt ::= COLUMNKW",
  /* 309 */ "cmd ::= create_vtab",
  /* 310 */ "cmd ::= create_vtab LP vtabarglist RP",
  /* 311 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
  /* 312 */ "vtabarglist ::= vtabarg",
  /* 313 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
  /* 314 */ "vtabarg ::=",
  /* 315 */ "vtabarg ::= vtabarg vtabargtoken",
  /* 316 */ "vtabargtoken ::= ANY",
  /* 317 */ "vtabargtoken ::= lp anylist RP",
  /* 318 */ "lp ::= LP",
  /* 319 */ "anylist ::=",
  /* 320 */ "anylist ::= anylist LP anylist RP",
  /* 321 */ "anylist ::= anylist ANY",
  /* 322 */ "with ::=",
  /* 323 */ "with ::= WITH wqlist",
  /* 324 */ "with ::= WITH RECURSIVE wqlist",
  /* 325 */ "wqlist ::= nm idxlist_opt AS LP select RP",
  /* 326 */ "wqlist ::= wqlist COMMA nm idxlist_opt AS LP select RP",
 };
 #endif /* NDEBUG */

@@ -114193,76 +116732,76 @@ static void yy_destructor(

     ** which appear on the RHS of the rule, but which are not used
     ** inside the C code.
     */
     case 160: /* select */
     case 194: /* oneselect */
     case 163: /* select */
     case 195: /* selectnowith */
     case 196: /* oneselect */
     case 207: /* values */
 {
 sqlite3SelectDelete(pParse->db, (yypminor->yy159));
 sqlite3SelectDelete(pParse->db, (yypminor->yy3));
 }
       break;
     case 173: /* term */
     case 174: /* expr */
     case 174: /* term */
     case 175: /* expr */
 {
 sqlite3ExprDelete(pParse->db, (yypminor->yy342).pExpr);
 sqlite3ExprDelete(pParse->db, (yypminor->yy346).pExpr);
 }
       break;
     case 178: /* idxlist_opt */
     case 187: /* idxlist */
     case 197: /* selcollist */
     case 200: /* groupby_opt */
     case 202: /* orderby_opt */
     case 204: /* sclp */
     case 214: /* sortlist */
     case 215: /* nexprlist */
     case 216: /* setlist */
     case 220: /* exprlist */
     case 225: /* case_exprlist */
     case 179: /* idxlist_opt */
     case 188: /* idxlist */
     case 200: /* selcollist */
     case 203: /* groupby_opt */
     case 205: /* orderby_opt */
     case 208: /* nexprlist */
     case 209: /* exprlist */
     case 210: /* sclp */
     case 220: /* sortlist */
     case 221: /* setlist */
     case 228: /* case_exprlist */
 {
 sqlite3ExprListDelete(pParse->db, (yypminor->yy442));
 sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
 }
       break;
     case 193: /* fullname */
     case 198: /* from */
     case 206: /* seltablist */
     case 207: /* stl_prefix */
     case 194: /* fullname */
     case 201: /* from */
     case 212: /* seltablist */
     case 213: /* stl_prefix */
 {
 sqlite3SrcListDelete(pParse->db, (yypminor->yy347));
 sqlite3SrcListDelete(pParse->db, (yypminor->yy65));
 }
       break;
     case 199: /* where_opt */
     case 201: /* having_opt */
     case 210: /* on_opt */
     case 224: /* case_operand */
     case 226: /* case_else */
     case 236: /* when_clause */
     case 241: /* key_opt */
     case 197: /* with */
     case 252: /* wqlist */
 {
 sqlite3ExprDelete(pParse->db, (yypminor->yy122));
 sqlite3WithDelete(pParse->db, (yypminor->yy59));
 }
       break;
     case 211: /* using_opt */
     case 213: /* inscollist */
     case 218: /* inscollist_opt */
     case 202: /* where_opt */
     case 204: /* having_opt */
     case 216: /* on_opt */
     case 227: /* case_operand */
     case 229: /* case_else */
     case 238: /* when_clause */
     case 243: /* key_opt */
 {
 sqlite3IdListDelete(pParse->db, (yypminor->yy180));
 sqlite3ExprDelete(pParse->db, (yypminor->yy132));
 }
       break;
     case 219: /* valuelist */
     case 217: /* using_opt */
     case 219: /* idlist */
     case 223: /* inscollist_opt */
 {
   sqlite3ExprListDelete(pParse->db, (yypminor->yy487).pList);
   sqlite3SelectDelete(pParse->db, (yypminor->yy487).pSelect);
 sqlite3IdListDelete(pParse->db, (yypminor->yy408));
 }
       break;
     case 232: /* trigger_cmd_list */
     case 237: /* trigger_cmd */
     case 234: /* trigger_cmd_list */
     case 239: /* trigger_cmd */
 {
 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy327));
 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy473));
 }
       break;
     case 234: /* trigger_event */
     case 236: /* trigger_event */
 {
 sqlite3IdListDelete(pParse->db, (yypminor->yy410).b);
 sqlite3IdListDelete(pParse->db, (yypminor->yy378).b);
 }
       break;
     default:  break;   /* If no destructor action specified: do nothing */

@@ -114507,333 +117046,333 @@ static const struct {

   YYCODETYPE lhs;         /* Symbol on the left-hand side of the rule */
   unsigned char nrhs;     /* Number of right-hand side symbols in the rule */
 } yyRuleInfo[] = {
   { 142, 1 },
   { 143, 2 },
   { 143, 1 },
   { 144, 1 },
   { 144, 3 },
   { 145, 0 },
   { 145, 2 },
   { 145, 1 },
   { 145, 3 },
   { 146, 1 },
   { 146, 3 },
   { 147, 0 },
   { 147, 1 },
   { 147, 3 },
   { 149, 0 },
   { 149, 1 },
   { 149, 2 },
   { 148, 0 },
   { 148, 1 },
   { 148, 1 },
   { 148, 1 },
   { 147, 2 },
   { 147, 2 },
   { 147, 2 },
   { 151, 1 },
   { 149, 3 },
   { 151, 0 },
   { 147, 2 },
   { 147, 3 },
   { 147, 5 },
   { 147, 2 },
   { 152, 6 },
   { 154, 1 },
   { 156, 0 },
   { 156, 3 },
   { 155, 1 },
   { 155, 0 },
   { 153, 4 },
   { 153, 2 },
   { 158, 3 },
   { 158, 1 },
   { 161, 3 },
   { 162, 1 },
   { 165, 1 },
   { 165, 1 },
   { 166, 1 },
   { 151, 1 },
   { 151, 2 },
   { 150, 0 },
   { 150, 1 },
   { 150, 1 },
   { 150, 1 },
   { 163, 0 },
   { 163, 1 },
   { 167, 1 },
   { 167, 4 },
   { 167, 6 },
   { 149, 2 },
   { 149, 2 },
   { 149, 2 },
   { 153, 1 },
   { 153, 0 },
   { 149, 2 },
   { 149, 3 },
   { 149, 5 },
   { 149, 2 },
   { 154, 6 },
   { 156, 1 },
   { 158, 0 },
   { 158, 3 },
   { 157, 1 },
   { 157, 0 },
   { 155, 5 },
   { 155, 2 },
   { 162, 0 },
   { 162, 2 },
   { 160, 3 },
   { 160, 1 },
   { 164, 3 },
   { 165, 1 },
   { 152, 1 },
   { 152, 1 },
   { 152, 1 },
   { 166, 0 },
   { 166, 1 },
   { 168, 1 },
   { 168, 2 },
   { 168, 4 },
   { 168, 6 },
   { 169, 1 },
   { 169, 1 },
   { 164, 2 },
   { 164, 0 },
   { 172, 2 },
   { 172, 2 },
   { 172, 4 },
   { 172, 3 },
   { 172, 3 },
   { 172, 2 },
   { 172, 2 },
   { 172, 3 },
   { 172, 5 },
   { 172, 2 },
   { 172, 4 },
   { 172, 4 },
   { 172, 1 },
   { 172, 2 },
   { 177, 0 },
   { 177, 1 },
   { 179, 0 },
   { 179, 2 },
   { 181, 2 },
   { 181, 3 },
   { 181, 3 },
   { 181, 3 },
   { 182, 2 },
   { 182, 2 },
   { 182, 1 },
   { 182, 1 },
   { 182, 2 },
   { 180, 3 },
   { 169, 2 },
   { 170, 1 },
   { 170, 1 },
   { 167, 2 },
   { 167, 0 },
   { 173, 2 },
   { 173, 2 },
   { 173, 4 },
   { 173, 3 },
   { 173, 3 },
   { 173, 2 },
   { 173, 2 },
   { 173, 3 },
   { 173, 5 },
   { 173, 2 },
   { 173, 4 },
   { 173, 4 },
   { 173, 1 },
   { 173, 2 },
   { 178, 0 },
   { 178, 1 },
   { 180, 0 },
   { 180, 2 },
   { 183, 0 },
   { 182, 2 },
   { 182, 3 },
   { 182, 3 },
   { 182, 3 },
   { 183, 2 },
   { 183, 2 },
   { 159, 0 },
   { 159, 2 },
   { 184, 3 },
   { 184, 1 },
   { 183, 1 },
   { 183, 1 },
   { 183, 2 },
   { 181, 3 },
   { 181, 2 },
   { 184, 0 },
   { 184, 2 },
   { 184, 2 },
   { 161, 0 },
   { 161, 2 },
   { 185, 3 },
   { 185, 1 },
   { 185, 0 },
   { 186, 2 },
   { 186, 7 },
   { 186, 5 },
   { 186, 5 },
   { 186, 10 },
   { 188, 0 },
   { 188, 1 },
   { 175, 0 },
   { 175, 3 },
   { 186, 1 },
   { 186, 0 },
   { 187, 2 },
   { 187, 7 },
   { 187, 5 },
   { 187, 5 },
   { 187, 10 },
   { 189, 0 },
   { 189, 2 },
   { 190, 1 },
   { 190, 1 },
   { 190, 1 },
   { 147, 4 },
   { 192, 2 },
   { 192, 0 },
   { 147, 8 },
   { 147, 4 },
   { 147, 1 },
   { 160, 1 },
   { 160, 3 },
   { 195, 1 },
   { 195, 2 },
   { 189, 1 },
   { 176, 0 },
   { 176, 3 },
   { 190, 0 },
   { 190, 2 },
   { 191, 1 },
   { 191, 1 },
   { 191, 1 },
   { 149, 4 },
   { 193, 2 },
   { 193, 0 },
   { 149, 8 },
   { 149, 4 },
   { 149, 1 },
   { 163, 2 },
   { 195, 1 },
   { 194, 9 },
   { 196, 1 },
   { 196, 1 },
   { 196, 0 },
   { 204, 2 },
   { 204, 0 },
   { 197, 3 },
   { 197, 2 },
   { 197, 4 },
   { 205, 2 },
   { 205, 1 },
   { 205, 0 },
   { 198, 0 },
   { 195, 3 },
   { 198, 1 },
   { 198, 2 },
   { 207, 2 },
   { 207, 0 },
   { 206, 7 },
   { 206, 7 },
   { 206, 7 },
   { 157, 0 },
   { 157, 2 },
   { 193, 2 },
   { 208, 1 },
   { 208, 2 },
   { 208, 3 },
   { 208, 4 },
   { 198, 1 },
   { 196, 9 },
   { 196, 1 },
   { 207, 4 },
   { 207, 5 },
   { 199, 1 },
   { 199, 1 },
   { 199, 0 },
   { 210, 2 },
   { 210, 0 },
   { 209, 0 },
   { 209, 3 },
   { 209, 2 },
   { 211, 4 },
   { 211, 0 },
   { 202, 0 },
   { 202, 3 },
   { 214, 4 },
   { 214, 2 },
   { 176, 1 },
   { 176, 1 },
   { 176, 0 },
   { 200, 0 },
   { 200, 3 },
   { 200, 2 },
   { 200, 4 },
   { 211, 2 },
   { 211, 1 },
   { 211, 0 },
   { 201, 0 },
   { 201, 2 },
   { 213, 2 },
   { 213, 0 },
   { 212, 7 },
   { 212, 7 },
   { 212, 7 },
   { 159, 0 },
   { 159, 2 },
   { 194, 2 },
   { 214, 1 },
   { 214, 2 },
   { 214, 3 },
   { 214, 4 },
   { 216, 2 },
   { 216, 0 },
   { 215, 0 },
   { 215, 3 },
   { 215, 2 },
   { 217, 4 },
   { 217, 0 },
   { 205, 0 },
   { 205, 3 },
   { 220, 4 },
   { 220, 2 },
   { 177, 1 },
   { 177, 1 },
   { 177, 0 },
   { 203, 0 },
   { 203, 2 },
   { 203, 4 },
   { 203, 4 },
   { 147, 5 },
   { 199, 0 },
   { 199, 2 },
   { 147, 7 },
   { 216, 5 },
   { 216, 3 },
   { 147, 5 },
   { 147, 5 },
   { 147, 6 },
   { 217, 2 },
   { 217, 1 },
   { 219, 4 },
   { 219, 5 },
   { 218, 0 },
   { 218, 3 },
   { 213, 3 },
   { 213, 1 },
   { 203, 3 },
   { 204, 0 },
   { 204, 2 },
   { 206, 0 },
   { 206, 2 },
   { 206, 4 },
   { 206, 4 },
   { 149, 6 },
   { 202, 0 },
   { 202, 2 },
   { 149, 8 },
   { 221, 5 },
   { 221, 3 },
   { 149, 6 },
   { 149, 7 },
   { 222, 2 },
   { 222, 1 },
   { 223, 0 },
   { 223, 3 },
   { 219, 3 },
   { 219, 1 },
   { 175, 1 },
   { 175, 3 },
   { 174, 1 },
   { 174, 3 },
   { 173, 1 },
   { 175, 1 },
   { 175, 1 },
   { 175, 3 },
   { 175, 5 },
   { 174, 1 },
   { 174, 1 },
   { 174, 3 },
   { 174, 5 },
   { 173, 1 },
   { 173, 1 },
   { 174, 1 },
   { 175, 1 },
   { 175, 3 },
   { 175, 6 },
   { 175, 5 },
   { 175, 4 },
   { 174, 1 },
   { 174, 3 },
   { 174, 6 },
   { 174, 5 },
   { 174, 4 },
   { 173, 1 },
   { 174, 3 },
   { 174, 3 },
   { 174, 3 },
   { 174, 3 },
   { 174, 3 },
   { 174, 3 },
   { 174, 3 },
   { 174, 3 },
   { 221, 1 },
   { 221, 2 },
   { 221, 1 },
   { 221, 2 },
   { 174, 3 },
   { 174, 5 },
   { 174, 2 },
   { 174, 3 },
   { 174, 3 },
   { 174, 4 },
   { 174, 2 },
   { 174, 2 },
   { 174, 2 },
   { 174, 2 },
   { 222, 1 },
   { 222, 2 },
   { 174, 5 },
   { 223, 1 },
   { 223, 2 },
   { 174, 5 },
   { 174, 3 },
   { 174, 5 },
   { 174, 4 },
   { 174, 4 },
   { 174, 5 },
   { 225, 5 },
   { 225, 4 },
   { 226, 2 },
   { 226, 0 },
   { 175, 3 },
   { 175, 3 },
   { 175, 3 },
   { 175, 3 },
   { 175, 3 },
   { 175, 3 },
   { 175, 3 },
   { 175, 3 },
   { 224, 1 },
   { 224, 0 },
   { 220, 1 },
   { 220, 0 },
   { 215, 3 },
   { 215, 1 },
   { 147, 12 },
   { 224, 2 },
   { 175, 3 },
   { 175, 5 },
   { 175, 2 },
   { 175, 3 },
   { 175, 3 },
   { 175, 4 },
   { 175, 2 },
   { 175, 2 },
   { 175, 2 },
   { 175, 2 },
   { 225, 1 },
   { 225, 2 },
   { 175, 5 },
   { 226, 1 },
   { 226, 2 },
   { 175, 5 },
   { 175, 3 },
   { 175, 5 },
   { 175, 4 },
   { 175, 4 },
   { 175, 5 },
   { 228, 5 },
   { 228, 4 },
   { 229, 2 },
   { 229, 0 },
   { 227, 1 },
   { 227, 0 },
   { 178, 0 },
   { 178, 3 },
   { 187, 5 },
   { 187, 3 },
   { 228, 0 },
   { 228, 2 },
   { 147, 4 },
   { 147, 1 },
   { 147, 2 },
   { 147, 3 },
   { 147, 5 },
   { 147, 6 },
   { 147, 5 },
   { 147, 6 },
   { 229, 1 },
   { 229, 1 },
   { 229, 1 },
   { 229, 1 },
   { 229, 1 },
   { 170, 2 },
   { 170, 1 },
   { 171, 2 },
   { 209, 1 },
   { 209, 0 },
   { 208, 3 },
   { 208, 1 },
   { 149, 12 },
   { 230, 1 },
   { 147, 5 },
   { 231, 11 },
   { 233, 1 },
   { 233, 1 },
   { 233, 2 },
   { 233, 0 },
   { 234, 1 },
   { 234, 1 },
   { 234, 3 },
   { 230, 0 },
   { 179, 0 },
   { 179, 3 },
   { 188, 5 },
   { 188, 3 },
   { 231, 0 },
   { 231, 2 },
   { 149, 4 },
   { 149, 1 },
   { 149, 2 },
   { 149, 3 },
   { 149, 5 },
   { 149, 6 },
   { 149, 5 },
   { 149, 6 },
   { 232, 1 },
   { 232, 1 },
   { 232, 1 },
   { 232, 1 },
   { 232, 1 },
   { 171, 2 },
   { 171, 1 },
   { 172, 2 },
   { 149, 5 },
   { 233, 11 },
   { 235, 1 },
   { 235, 1 },
   { 235, 2 },
   { 235, 0 },
   { 235, 3 },
   { 236, 0 },
   { 236, 2 },
   { 232, 3 },
   { 232, 2 },
   { 238, 1 },
   { 238, 3 },
   { 239, 0 },
   { 239, 3 },
   { 239, 2 },
   { 237, 7 },
   { 237, 5 },
   { 237, 5 },
   { 237, 5 },
   { 237, 1 },
   { 174, 4 },
   { 174, 6 },
   { 191, 1 },
   { 191, 1 },
   { 191, 1 },
   { 147, 4 },
   { 147, 6 },
   { 147, 3 },
   { 236, 1 },
   { 236, 1 },
   { 236, 3 },
   { 237, 0 },
   { 237, 3 },
   { 238, 0 },
   { 238, 2 },
   { 234, 3 },
   { 234, 2 },
   { 240, 1 },
   { 240, 3 },
   { 241, 0 },
   { 241, 3 },
   { 241, 2 },
   { 240, 1 },
   { 240, 0 },
   { 147, 1 },
   { 147, 3 },
   { 147, 1 },
   { 147, 3 },
   { 147, 6 },
   { 147, 6 },
   { 242, 1 },
   { 239, 7 },
   { 239, 5 },
   { 239, 5 },
   { 239, 1 },
   { 175, 4 },
   { 175, 6 },
   { 192, 1 },
   { 192, 1 },
   { 192, 1 },
   { 149, 4 },
   { 149, 6 },
   { 149, 3 },
   { 243, 0 },
   { 243, 1 },
   { 147, 1 },
   { 147, 4 },
   { 244, 8 },
   { 243, 2 },
   { 242, 1 },
   { 242, 0 },
   { 149, 1 },
   { 149, 3 },
   { 149, 1 },
   { 149, 3 },
   { 149, 6 },
   { 149, 6 },
   { 244, 1 },
   { 245, 0 },
   { 245, 1 },
   { 245, 3 },
   { 246, 0 },
   { 246, 2 },
   { 149, 1 },
   { 149, 4 },
   { 246, 8 },
   { 247, 1 },
   { 247, 3 },
   { 248, 1 },
   { 249, 0 },
   { 249, 4 },
   { 249, 2 },
   { 248, 0 },
   { 248, 2 },
   { 249, 1 },
   { 249, 3 },
   { 250, 1 },
   { 251, 0 },
   { 251, 4 },
   { 251, 2 },
   { 197, 0 },
   { 197, 2 },
   { 197, 3 },
   { 252, 6 },
   { 252, 8 },
 };
 static void yy_accept(yyParser*);  /* Forward Declaration */

@@ -114901,17 +117440,17 @@ static void yy_reduce(

 { sqlite3FinishCoding(pParse); }
         break;
       case 9: /* cmd ::= BEGIN transtype trans_opt */
 {sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy392);}
 {sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy328);}
         break;
       case 13: /* transtype ::= */
 {yygotominor.yy392 = TK_DEFERRED;}
 {yygotominor.yy328 = TK_DEFERRED;}
         break;
       case 14: /* transtype ::= DEFERRED */
       case 15: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==15);
       case 16: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==16);
       case 115: /* multiselect_op ::= UNION */ yytestcase(yyruleno==115);
       case 117: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==117);
 {yygotominor.yy392 = yymsp[0].major;}
 {yygotominor.yy328 = yymsp[0].major;}
         break;
       case 17: /* cmd ::= COMMIT trans_opt */
       case 18: /* cmd ::= END trans_opt */ yytestcase(yyruleno==18);

@@ -114937,7 +117476,7 @@ static void yy_reduce(

         break;
       case 26: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
 {
    sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy392,0,0,yymsp[-2].minor.yy392);
    sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy328,0,0,yymsp[-2].minor.yy328);
 }
         break;
       case 27: /* createkw ::= CREATE */

@@ -114948,533 +117487,569 @@ static void yy_reduce(

         break;
       case 28: /* ifnotexists ::= */
       case 31: /* temp ::= */ yytestcase(yyruleno==31);
       case 69: /* autoinc ::= */ yytestcase(yyruleno==69);
       case 82: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ yytestcase(yyruleno==82);
       case 84: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==84);
       case 86: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ yytestcase(yyruleno==86);
       case 98: /* defer_subclause_opt ::= */ yytestcase(yyruleno==98);
       case 109: /* ifexists ::= */ yytestcase(yyruleno==109);
       case 221: /* between_op ::= BETWEEN */ yytestcase(yyruleno==221);
       case 224: /* in_op ::= IN */ yytestcase(yyruleno==224);
 {yygotominor.yy392 = 0;}
       case 68: /* autoinc ::= */ yytestcase(yyruleno==68);
       case 81: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ yytestcase(yyruleno==81);
       case 83: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==83);
       case 85: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ yytestcase(yyruleno==85);
       case 97: /* defer_subclause_opt ::= */ yytestcase(yyruleno==97);
       case 108: /* ifexists ::= */ yytestcase(yyruleno==108);
       case 218: /* between_op ::= BETWEEN */ yytestcase(yyruleno==218);
       case 221: /* in_op ::= IN */ yytestcase(yyruleno==221);
 {yygotominor.yy328 = 0;}
         break;
       case 29: /* ifnotexists ::= IF NOT EXISTS */
       case 30: /* temp ::= TEMP */ yytestcase(yyruleno==30);
       case 70: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==70);
       case 85: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ yytestcase(yyruleno==85);
       case 108: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==108);
       case 222: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==222);
       case 225: /* in_op ::= NOT IN */ yytestcase(yyruleno==225);
 {yygotominor.yy392 = 1;}
       case 69: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==69);
       case 84: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ yytestcase(yyruleno==84);
       case 107: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==107);
       case 219: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==219);
       case 222: /* in_op ::= NOT IN */ yytestcase(yyruleno==222);
 {yygotominor.yy328 = 1;}
         break;
       case 32: /* create_table_args ::= LP columnlist conslist_opt RP */
       case 32: /* create_table_args ::= LP columnlist conslist_opt RP table_options */
 {
   sqlite3EndTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0);
   sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy186,0);
 }
         break;
       case 33: /* create_table_args ::= AS select */
 {
   sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy159);
   sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy159);
   sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy3);
   sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
 }
         break;
       case 36: /* column ::= columnid type carglist */
       case 34: /* table_options ::= */
 {yygotominor.yy186 = 0;}
         break;
       case 35: /* table_options ::= WITHOUT nm */
 {
   if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
     yygotominor.yy186 = TF_WithoutRowid;
   }else{
     yygotominor.yy186 = 0;
     sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
   }
 }
         break;
       case 38: /* column ::= columnid type carglist */
 {
   yygotominor.yy0.z = yymsp[-2].minor.yy0.z;
   yygotominor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-2].minor.yy0.z) + pParse->sLastToken.n;
 }
         break;
       case 37: /* columnid ::= nm */
       case 39: /* columnid ::= nm */
 {
   sqlite3AddColumn(pParse,&yymsp[0].minor.yy0);
   yygotominor.yy0 = yymsp[0].minor.yy0;
   pParse->constraintName.n = 0;
 }
         break;
       case 38: /* id ::= ID */
       case 39: /* id ::= INDEXED */ yytestcase(yyruleno==39);
       case 40: /* ids ::= ID|STRING */ yytestcase(yyruleno==40);
       case 41: /* nm ::= id */ yytestcase(yyruleno==41);
       case 42: /* nm ::= STRING */ yytestcase(yyruleno==42);
       case 43: /* nm ::= JOIN_KW */ yytestcase(yyruleno==43);
       case 46: /* typetoken ::= typename */ yytestcase(yyruleno==46);
       case 49: /* typename ::= ids */ yytestcase(yyruleno==49);
       case 127: /* as ::= AS nm */ yytestcase(yyruleno==127);
       case 128: /* as ::= ids */ yytestcase(yyruleno==128);
       case 138: /* dbnm ::= DOT nm */ yytestcase(yyruleno==138);
       case 147: /* indexed_opt ::= INDEXED BY nm */ yytestcase(yyruleno==147);
       case 250: /* collate ::= COLLATE ids */ yytestcase(yyruleno==250);
       case 259: /* nmnum ::= plus_num */ yytestcase(yyruleno==259);
       case 260: /* nmnum ::= nm */ yytestcase(yyruleno==260);
       case 261: /* nmnum ::= ON */ yytestcase(yyruleno==261);
       case 262: /* nmnum ::= DELETE */ yytestcase(yyruleno==262);
       case 263: /* nmnum ::= DEFAULT */ yytestcase(yyruleno==263);
       case 264: /* plus_num ::= PLUS number */ yytestcase(yyruleno==264);
       case 265: /* plus_num ::= number */ yytestcase(yyruleno==265);
       case 266: /* minus_num ::= MINUS number */ yytestcase(yyruleno==266);
       case 267: /* number ::= INTEGER|FLOAT */ yytestcase(yyruleno==267);
       case 283: /* trnm ::= nm */ yytestcase(yyruleno==283);
       case 40: /* nm ::= ID|INDEXED */
       case 41: /* nm ::= STRING */ yytestcase(yyruleno==41);
       case 42: /* nm ::= JOIN_KW */ yytestcase(yyruleno==42);
       case 45: /* typetoken ::= typename */ yytestcase(yyruleno==45);
       case 48: /* typename ::= ID|STRING */ yytestcase(yyruleno==48);
       case 130: /* as ::= AS nm */ yytestcase(yyruleno==130);
       case 131: /* as ::= ID|STRING */ yytestcase(yyruleno==131);
       case 141: /* dbnm ::= DOT nm */ yytestcase(yyruleno==141);
       case 150: /* indexed_opt ::= INDEXED BY nm */ yytestcase(yyruleno==150);
       case 247: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==247);
       case 256: /* nmnum ::= plus_num */ yytestcase(yyruleno==256);
       case 257: /* nmnum ::= nm */ yytestcase(yyruleno==257);
       case 258: /* nmnum ::= ON */ yytestcase(yyruleno==258);
       case 259: /* nmnum ::= DELETE */ yytestcase(yyruleno==259);
       case 260: /* nmnum ::= DEFAULT */ yytestcase(yyruleno==260);
       case 261: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==261);
       case 262: /* plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==262);
       case 263: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==263);
       case 279: /* trnm ::= nm */ yytestcase(yyruleno==279);
 {yygotominor.yy0 = yymsp[0].minor.yy0;}
         break;
       case 45: /* type ::= typetoken */
       case 44: /* type ::= typetoken */
 {sqlite3AddColumnType(pParse,&yymsp[0].minor.yy0);}
         break;
       case 47: /* typetoken ::= typename LP signed RP */
       case 46: /* typetoken ::= typename LP signed RP */
 {
   yygotominor.yy0.z = yymsp[-3].minor.yy0.z;
   yygotominor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
 }
         break;
       case 48: /* typetoken ::= typename LP signed COMMA signed RP */
       case 47: /* typetoken ::= typename LP signed COMMA signed RP */
 {
   yygotominor.yy0.z = yymsp[-5].minor.yy0.z;
   yygotominor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z);
 }
         break;
       case 50: /* typename ::= typename ids */
       case 49: /* typename ::= typename ID|STRING */
 {yygotominor.yy0.z=yymsp[-1].minor.yy0.z; yygotominor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
         break;
       case 55: /* ccons ::= CONSTRAINT nm */
       case 93: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==93);
       case 54: /* ccons ::= CONSTRAINT nm */
       case 92: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==92);
 {pParse->constraintName = yymsp[0].minor.yy0;}
         break;
       case 56: /* ccons ::= DEFAULT term */
       case 58: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==58);
 {sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy342);}
       case 55: /* ccons ::= DEFAULT term */
       case 57: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==57);
 {sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy346);}
         break;
       case 57: /* ccons ::= DEFAULT LP expr RP */
 {sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy342);}
       case 56: /* ccons ::= DEFAULT LP expr RP */
 {sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy346);}
         break;
       case 59: /* ccons ::= DEFAULT MINUS term */
       case 58: /* ccons ::= DEFAULT MINUS term */
 {
   ExprSpan v;
   v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy342.pExpr, 0, 0);
   v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy346.pExpr, 0, 0);
   v.zStart = yymsp[-1].minor.yy0.z;
   v.zEnd = yymsp[0].minor.yy342.zEnd;
   v.zEnd = yymsp[0].minor.yy346.zEnd;
   sqlite3AddDefaultValue(pParse,&v);
 }
         break;
       case 60: /* ccons ::= DEFAULT id */
       case 59: /* ccons ::= DEFAULT ID|INDEXED */
 {
   ExprSpan v;
   spanExpr(&v, pParse, TK_STRING, &yymsp[0].minor.yy0);
   sqlite3AddDefaultValue(pParse,&v);
 }
         break;
       case 62: /* ccons ::= NOT NULL onconf */
 {sqlite3AddNotNull(pParse, yymsp[0].minor.yy392);}
       case 61: /* ccons ::= NOT NULL onconf */
 {sqlite3AddNotNull(pParse, yymsp[0].minor.yy328);}
         break;
       case 63: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
 {sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy392,yymsp[0].minor.yy392,yymsp[-2].minor.yy392);}
       case 62: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
 {sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy328,yymsp[0].minor.yy328,yymsp[-2].minor.yy328);}
         break;
       case 64: /* ccons ::= UNIQUE onconf */
 {sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy392,0,0,0,0);}
       case 63: /* ccons ::= UNIQUE onconf */
 {sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy328,0,0,0,0);}
         break;
       case 65: /* ccons ::= CHECK LP expr RP */
 {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy342.pExpr);}
       case 64: /* ccons ::= CHECK LP expr RP */
 {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy346.pExpr);}
         break;
       case 66: /* ccons ::= REFERENCES nm idxlist_opt refargs */
 {sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy442,yymsp[0].minor.yy392);}
       case 65: /* ccons ::= REFERENCES nm idxlist_opt refargs */
 {sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy328);}
         break;
       case 67: /* ccons ::= defer_subclause */
 {sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy392);}
       case 66: /* ccons ::= defer_subclause */
 {sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy328);}
         break;
       case 68: /* ccons ::= COLLATE ids */
       case 67: /* ccons ::= COLLATE ID|STRING */
 {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
         break;
       case 71: /* refargs ::= */
 { yygotominor.yy392 = OE_None*0x0101; /* EV: R-19803-45884 */}
       case 70: /* refargs ::= */
 { yygotominor.yy328 = OE_None*0x0101; /* EV: R-19803-45884 */}
         break;
       case 72: /* refargs ::= refargs refarg */
 { yygotominor.yy392 = (yymsp[-1].minor.yy392 & ~yymsp[0].minor.yy207.mask) | yymsp[0].minor.yy207.value; }
       case 71: /* refargs ::= refargs refarg */
 { yygotominor.yy328 = (yymsp[-1].minor.yy328 & ~yymsp[0].minor.yy429.mask) | yymsp[0].minor.yy429.value; }
         break;
       case 73: /* refarg ::= MATCH nm */
       case 74: /* refarg ::= ON INSERT refact */ yytestcase(yyruleno==74);
 { yygotominor.yy207.value = 0;     yygotominor.yy207.mask = 0x000000; }
       case 72: /* refarg ::= MATCH nm */
       case 73: /* refarg ::= ON INSERT refact */ yytestcase(yyruleno==73);
 { yygotominor.yy429.value = 0;     yygotominor.yy429.mask = 0x000000; }
         break;
       case 75: /* refarg ::= ON DELETE refact */
 { yygotominor.yy207.value = yymsp[0].minor.yy392;     yygotominor.yy207.mask = 0x0000ff; }
       case 74: /* refarg ::= ON DELETE refact */
 { yygotominor.yy429.value = yymsp[0].minor.yy328;     yygotominor.yy429.mask = 0x0000ff; }
         break;
       case 76: /* refarg ::= ON UPDATE refact */
 { yygotominor.yy207.value = yymsp[0].minor.yy392<<8;  yygotominor.yy207.mask = 0x00ff00; }
       case 75: /* refarg ::= ON UPDATE refact */
 { yygotominor.yy429.value = yymsp[0].minor.yy328<<8;  yygotominor.yy429.mask = 0x00ff00; }
         break;
       case 77: /* refact ::= SET NULL */
 { yygotominor.yy392 = OE_SetNull;  /* EV: R-33326-45252 */}
       case 76: /* refact ::= SET NULL */
 { yygotominor.yy328 = OE_SetNull;  /* EV: R-33326-45252 */}
         break;
       case 78: /* refact ::= SET DEFAULT */
 { yygotominor.yy392 = OE_SetDflt;  /* EV: R-33326-45252 */}
       case 77: /* refact ::= SET DEFAULT */
 { yygotominor.yy328 = OE_SetDflt;  /* EV: R-33326-45252 */}
         break;
       case 79: /* refact ::= CASCADE */
 { yygotominor.yy392 = OE_Cascade;  /* EV: R-33326-45252 */}
       case 78: /* refact ::= CASCADE */
 { yygotominor.yy328 = OE_Cascade;  /* EV: R-33326-45252 */}
         break;
       case 80: /* refact ::= RESTRICT */
 { yygotominor.yy392 = OE_Restrict; /* EV: R-33326-45252 */}
       case 79: /* refact ::= RESTRICT */
 { yygotominor.yy328 = OE_Restrict; /* EV: R-33326-45252 */}
         break;
       case 81: /* refact ::= NO ACTION */
 { yygotominor.yy392 = OE_None;     /* EV: R-33326-45252 */}
       case 80: /* refact ::= NO ACTION */
 { yygotominor.yy328 = OE_None;     /* EV: R-33326-45252 */}
         break;
       case 83: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
       case 99: /* defer_subclause_opt ::= defer_subclause */ yytestcase(yyruleno==99);
       case 101: /* onconf ::= ON CONFLICT resolvetype */ yytestcase(yyruleno==101);
       case 104: /* resolvetype ::= raisetype */ yytestcase(yyruleno==104);
 {yygotominor.yy392 = yymsp[0].minor.yy392;}
       case 82: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
       case 98: /* defer_subclause_opt ::= defer_subclause */ yytestcase(yyruleno==98);
       case 100: /* onconf ::= ON CONFLICT resolvetype */ yytestcase(yyruleno==100);
       case 103: /* resolvetype ::= raisetype */ yytestcase(yyruleno==103);
 {yygotominor.yy328 = yymsp[0].minor.yy328;}
         break;
       case 87: /* conslist_opt ::= */
       case 86: /* conslist_opt ::= */
 {yygotominor.yy0.n = 0; yygotominor.yy0.z = 0;}
         break;
       case 88: /* conslist_opt ::= COMMA conslist */
       case 87: /* conslist_opt ::= COMMA conslist */
 {yygotominor.yy0 = yymsp[-1].minor.yy0;}
         break;
       case 91: /* tconscomma ::= COMMA */
       case 90: /* tconscomma ::= COMMA */
 {pParse->constraintName.n = 0;}
         break;
       case 94: /* tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf */
 {sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy442,yymsp[0].minor.yy392,yymsp[-2].minor.yy392,0);}
       case 93: /* tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf */
 {sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy328,yymsp[-2].minor.yy328,0);}
         break;
       case 95: /* tcons ::= UNIQUE LP idxlist RP onconf */
 {sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy442,yymsp[0].minor.yy392,0,0,0,0);}
       case 94: /* tcons ::= UNIQUE LP idxlist RP onconf */
 {sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy328,0,0,0,0);}
         break;
       case 96: /* tcons ::= CHECK LP expr RP onconf */
 {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy342.pExpr);}
       case 95: /* tcons ::= CHECK LP expr RP onconf */
 {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy346.pExpr);}
         break;
       case 97: /* tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt */
       case 96: /* tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt */
 {
     sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy442, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy442, yymsp[-1].minor.yy392);
     sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy392);
     sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy328);
     sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy328);
 }
         break;
       case 100: /* onconf ::= */
 {yygotominor.yy392 = OE_Default;}
       case 99: /* onconf ::= */
 {yygotominor.yy328 = OE_Default;}
         break;
       case 102: /* orconf ::= */
 {yygotominor.yy258 = OE_Default;}
       case 101: /* orconf ::= */
 {yygotominor.yy186 = OE_Default;}
         break;
       case 103: /* orconf ::= OR resolvetype */
 {yygotominor.yy258 = (u8)yymsp[0].minor.yy392;}
       case 102: /* orconf ::= OR resolvetype */
 {yygotominor.yy186 = (u8)yymsp[0].minor.yy328;}
         break;
       case 105: /* resolvetype ::= IGNORE */
 {yygotominor.yy392 = OE_Ignore;}
       case 104: /* resolvetype ::= IGNORE */
 {yygotominor.yy328 = OE_Ignore;}
         break;
       case 106: /* resolvetype ::= REPLACE */
 {yygotominor.yy392 = OE_Replace;}
       case 105: /* resolvetype ::= REPLACE */
 {yygotominor.yy328 = OE_Replace;}
         break;
       case 107: /* cmd ::= DROP TABLE ifexists fullname */
       case 106: /* cmd ::= DROP TABLE ifexists fullname */
 {
   sqlite3DropTable(pParse, yymsp[0].minor.yy347, 0, yymsp[-1].minor.yy392);
   sqlite3DropTable(pParse, yymsp[0].minor.yy65, 0, yymsp[-1].minor.yy328);
 }
         break;
       case 110: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select */
       case 109: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select */
 {
   sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy159, yymsp[-6].minor.yy392, yymsp[-4].minor.yy392);
   sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy3, yymsp[-6].minor.yy328, yymsp[-4].minor.yy328);
 }
         break;
       case 111: /* cmd ::= DROP VIEW ifexists fullname */
       case 110: /* cmd ::= DROP VIEW ifexists fullname */
 {
   sqlite3DropTable(pParse, yymsp[0].minor.yy347, 1, yymsp[-1].minor.yy392);
   sqlite3DropTable(pParse, yymsp[0].minor.yy65, 1, yymsp[-1].minor.yy328);
 }
         break;
       case 112: /* cmd ::= select */
       case 111: /* cmd ::= select */
 {
   SelectDest dest = {SRT_Output, 0, 0, 0, 0};
   sqlite3Select(pParse, yymsp[0].minor.yy159, &dest);
   SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0};
   sqlite3Select(pParse, yymsp[0].minor.yy3, &dest);
   sqlite3ExplainBegin(pParse->pVdbe);
   sqlite3ExplainSelect(pParse->pVdbe, yymsp[0].minor.yy159);
   sqlite3ExplainSelect(pParse->pVdbe, yymsp[0].minor.yy3);
   sqlite3ExplainFinish(pParse->pVdbe);
   sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy159);
   sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
 }
         break;
       case 112: /* select ::= with selectnowith */
 {
   Select *p = yymsp[0].minor.yy3, *pNext, *pLoop;
   if( p ){
     int cnt = 0, mxSelect;
     p->pWith = yymsp[-1].minor.yy59;
     if( p->pPrior ){
       pNext = 0;
       for(pLoop=p; pLoop; pNext=pLoop, pLoop=pLoop->pPrior, cnt++){
         pLoop->pNext = pNext;
         pLoop->selFlags |= SF_Compound;
       }
       mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT];
       if( mxSelect && cnt>mxSelect ){
         sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
       }
     }
   }else{
     sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy59);
   }
   yygotominor.yy3 = p;
 }
         break;
       case 113: /* select ::= oneselect */
 {yygotominor.yy159 = yymsp[0].minor.yy159;}
       case 113: /* selectnowith ::= oneselect */
       case 119: /* oneselect ::= values */ yytestcase(yyruleno==119);
 {yygotominor.yy3 = yymsp[0].minor.yy3;}
         break;
       case 114: /* select ::= select multiselect_op oneselect */
       case 114: /* selectnowith ::= selectnowith multiselect_op oneselect */
 {
   if( yymsp[0].minor.yy159 ){
     yymsp[0].minor.yy159->op = (u8)yymsp[-1].minor.yy392;
     yymsp[0].minor.yy159->pPrior = yymsp[-2].minor.yy159;
     if( yymsp[-1].minor.yy392!=TK_ALL ) pParse->hasCompound = 1;
   Select *pRhs = yymsp[0].minor.yy3;
   if( pRhs && pRhs->pPrior ){
     SrcList *pFrom;
     Token x;
     x.n = 0;
     pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);
     pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0,0);
   }
   if( pRhs ){
     pRhs->op = (u8)yymsp[-1].minor.yy328;
     pRhs->pPrior = yymsp[-2].minor.yy3;
     if( yymsp[-1].minor.yy328!=TK_ALL ) pParse->hasCompound = 1;
   }else{
     sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy159);
     sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy3);
   }
   yygotominor.yy159 = yymsp[0].minor.yy159;
   yygotominor.yy3 = pRhs;
 }
         break;
       case 116: /* multiselect_op ::= UNION ALL */
 {yygotominor.yy392 = TK_ALL;}
 {yygotominor.yy328 = TK_ALL;}
         break;
       case 118: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
 {
   yygotominor.yy159 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy442,yymsp[-5].minor.yy347,yymsp[-4].minor.yy122,yymsp[-3].minor.yy442,yymsp[-2].minor.yy122,yymsp[-1].minor.yy442,yymsp[-7].minor.yy305,yymsp[0].minor.yy64.pLimit,yymsp[0].minor.yy64.pOffset);
   yygotominor.yy3 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy65,yymsp[-4].minor.yy132,yymsp[-3].minor.yy14,yymsp[-2].minor.yy132,yymsp[-1].minor.yy14,yymsp[-7].minor.yy381,yymsp[0].minor.yy476.pLimit,yymsp[0].minor.yy476.pOffset);
 }
         break;
       case 119: /* distinct ::= DISTINCT */
 {yygotominor.yy305 = SF_Distinct;}
       case 120: /* values ::= VALUES LP nexprlist RP */
 {
   yygotominor.yy3 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0,0);
 }
         break;
       case 120: /* distinct ::= ALL */
       case 121: /* distinct ::= */ yytestcase(yyruleno==121);
 {yygotominor.yy305 = 0;}
       case 121: /* values ::= values COMMA LP exprlist RP */
 {
   Select *pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0,0);
   if( pRight ){
     pRight->op = TK_ALL;
     pRight->pPrior = yymsp[-4].minor.yy3;
     yygotominor.yy3 = pRight;
   }else{
     yygotominor.yy3 = yymsp[-4].minor.yy3;
   }
 }
         break;
       case 122: /* distinct ::= DISTINCT */
 {yygotominor.yy381 = SF_Distinct;}
         break;
       case 122: /* sclp ::= selcollist COMMA */
       case 246: /* idxlist_opt ::= LP idxlist RP */ yytestcase(yyruleno==246);
 {yygotominor.yy442 = yymsp[-1].minor.yy442;}
       case 123: /* distinct ::= ALL */
       case 124: /* distinct ::= */ yytestcase(yyruleno==124);
 {yygotominor.yy381 = 0;}
         break;
       case 123: /* sclp ::= */
       case 151: /* orderby_opt ::= */ yytestcase(yyruleno==151);
       case 158: /* groupby_opt ::= */ yytestcase(yyruleno==158);
       case 239: /* exprlist ::= */ yytestcase(yyruleno==239);
       case 245: /* idxlist_opt ::= */ yytestcase(yyruleno==245);
 {yygotominor.yy442 = 0;}
       case 125: /* sclp ::= selcollist COMMA */
       case 243: /* idxlist_opt ::= LP idxlist RP */ yytestcase(yyruleno==243);
 {yygotominor.yy14 = yymsp[-1].minor.yy14;}
         break;
       case 124: /* selcollist ::= sclp expr as */
       case 126: /* sclp ::= */
       case 154: /* orderby_opt ::= */ yytestcase(yyruleno==154);
       case 161: /* groupby_opt ::= */ yytestcase(yyruleno==161);
       case 236: /* exprlist ::= */ yytestcase(yyruleno==236);
       case 242: /* idxlist_opt ::= */ yytestcase(yyruleno==242);
 {yygotominor.yy14 = 0;}
         break;
       case 127: /* selcollist ::= sclp expr as */
 {
    yygotominor.yy442 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy442, yymsp[-1].minor.yy342.pExpr);
    if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy442, &yymsp[0].minor.yy0, 1);
    sqlite3ExprListSetSpan(pParse,yygotominor.yy442,&yymsp[-1].minor.yy342);
    yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, yymsp[-1].minor.yy346.pExpr);
    if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[0].minor.yy0, 1);
    sqlite3ExprListSetSpan(pParse,yygotominor.yy14,&yymsp[-1].minor.yy346);
 }
         break;
       case 125: /* selcollist ::= sclp STAR */
       case 128: /* selcollist ::= sclp STAR */
 {
   Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
   yygotominor.yy442 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy442, p);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy14, p);
 }
         break;
       case 126: /* selcollist ::= sclp nm DOT STAR */
       case 129: /* selcollist ::= sclp nm DOT STAR */
 {
   Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &yymsp[0].minor.yy0);
   Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
   Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
   yygotominor.yy442 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy442, pDot);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, pDot);
 }
         break;
       case 129: /* as ::= */
       case 132: /* as ::= */
 {yygotominor.yy0.n = 0;}
         break;
       case 130: /* from ::= */
 {yygotominor.yy347 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy347));}
       case 133: /* from ::= */
 {yygotominor.yy65 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy65));}
         break;
       case 131: /* from ::= FROM seltablist */
       case 134: /* from ::= FROM seltablist */
 {
   yygotominor.yy347 = yymsp[0].minor.yy347;
   sqlite3SrcListShiftJoinType(yygotominor.yy347);
   yygotominor.yy65 = yymsp[0].minor.yy65;
   sqlite3SrcListShiftJoinType(yygotominor.yy65);
 }
         break;
       case 132: /* stl_prefix ::= seltablist joinop */
       case 135: /* stl_prefix ::= seltablist joinop */
 {
    yygotominor.yy347 = yymsp[-1].minor.yy347;
    if( ALWAYS(yygotominor.yy347 && yygotominor.yy347->nSrc>0) ) yygotominor.yy347->a[yygotominor.yy347->nSrc-1].jointype = (u8)yymsp[0].minor.yy392;
    yygotominor.yy65 = yymsp[-1].minor.yy65;
    if( ALWAYS(yygotominor.yy65 && yygotominor.yy65->nSrc>0) ) yygotominor.yy65->a[yygotominor.yy65->nSrc-1].jointype = (u8)yymsp[0].minor.yy328;
 }
         break;
       case 133: /* stl_prefix ::= */
 {yygotominor.yy347 = 0;}
       case 136: /* stl_prefix ::= */
 {yygotominor.yy65 = 0;}
         break;
       case 134: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
       case 137: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
 {
   yygotominor.yy347 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy347,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy122,yymsp[0].minor.yy180);
   sqlite3SrcListIndexedBy(pParse, yygotominor.yy347, &yymsp[-2].minor.yy0);
   yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
   sqlite3SrcListIndexedBy(pParse, yygotominor.yy65, &yymsp[-2].minor.yy0);
 }
         break;
       case 135: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
       case 138: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
 {
     yygotominor.yy347 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy347,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy159,yymsp[-1].minor.yy122,yymsp[0].minor.yy180);
     yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy3,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
   }
         break;
       case 136: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
       case 139: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
 {
     if( yymsp[-6].minor.yy347==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy122==0 && yymsp[0].minor.yy180==0 ){
       yygotominor.yy347 = yymsp[-4].minor.yy347;
     }else if( yymsp[-4].minor.yy347->nSrc==1 ){
       yygotominor.yy347 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy347,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy122,yymsp[0].minor.yy180);
       if( yygotominor.yy347 ){
         struct SrcList_item *pNew = &yygotominor.yy347->a[yygotominor.yy347->nSrc-1];
         struct SrcList_item *pOld = yymsp[-4].minor.yy347->a;
     if( yymsp[-6].minor.yy65==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy132==0 && yymsp[0].minor.yy408==0 ){
       yygotominor.yy65 = yymsp[-4].minor.yy65;
     }else if( yymsp[-4].minor.yy65->nSrc==1 ){
       yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
       if( yygotominor.yy65 ){
         struct SrcList_item *pNew = &yygotominor.yy65->a[yygotominor.yy65->nSrc-1];
         struct SrcList_item *pOld = yymsp[-4].minor.yy65->a;
         pNew->zName = pOld->zName;
         pNew->zDatabase = pOld->zDatabase;
         pNew->pSelect = pOld->pSelect;
         pOld->zName = pOld->zDatabase = 0;
         pOld->pSelect = 0;
       }
       sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy347);
       sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy65);
     }else{
       Select *pSubquery;
       sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy347);
       pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy347,0,0,0,0,SF_NestedFrom,0,0);
       yygotominor.yy347 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy347,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy122,yymsp[0].minor.yy180);
       sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy65);
       pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy65,0,0,0,0,SF_NestedFrom,0,0);
       yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
     }
   }
         break;
       case 137: /* dbnm ::= */
       case 146: /* indexed_opt ::= */ yytestcase(yyruleno==146);
       case 140: /* dbnm ::= */
       case 149: /* indexed_opt ::= */ yytestcase(yyruleno==149);
 {yygotominor.yy0.z=0; yygotominor.yy0.n=0;}
         break;
       case 139: /* fullname ::= nm dbnm */
 {yygotominor.yy347 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
       case 142: /* fullname ::= nm dbnm */
 {yygotominor.yy65 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
         break;
       case 140: /* joinop ::= COMMA|JOIN */
 { yygotominor.yy392 = JT_INNER; }
       case 143: /* joinop ::= COMMA|JOIN */
 { yygotominor.yy328 = JT_INNER; }
         break;
       case 141: /* joinop ::= JOIN_KW JOIN */
 { yygotominor.yy392 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
       case 144: /* joinop ::= JOIN_KW JOIN */
 { yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
         break;
       case 142: /* joinop ::= JOIN_KW nm JOIN */
 { yygotominor.yy392 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
       case 145: /* joinop ::= JOIN_KW nm JOIN */
 { yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
         break;
       case 143: /* joinop ::= JOIN_KW nm nm JOIN */
 { yygotominor.yy392 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
       case 146: /* joinop ::= JOIN_KW nm nm JOIN */
 { yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
         break;
       case 144: /* on_opt ::= ON expr */
       case 161: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==161);
       case 168: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==168);
       case 234: /* case_else ::= ELSE expr */ yytestcase(yyruleno==234);
       case 236: /* case_operand ::= expr */ yytestcase(yyruleno==236);
 {yygotominor.yy122 = yymsp[0].minor.yy342.pExpr;}
       case 147: /* on_opt ::= ON expr */
       case 164: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==164);
       case 171: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==171);
       case 231: /* case_else ::= ELSE expr */ yytestcase(yyruleno==231);
       case 233: /* case_operand ::= expr */ yytestcase(yyruleno==233);
 {yygotominor.yy132 = yymsp[0].minor.yy346.pExpr;}
         break;
       case 145: /* on_opt ::= */
       case 160: /* having_opt ::= */ yytestcase(yyruleno==160);
       case 167: /* where_opt ::= */ yytestcase(yyruleno==167);
       case 235: /* case_else ::= */ yytestcase(yyruleno==235);
       case 237: /* case_operand ::= */ yytestcase(yyruleno==237);
 {yygotominor.yy122 = 0;}
       case 148: /* on_opt ::= */
       case 163: /* having_opt ::= */ yytestcase(yyruleno==163);
       case 170: /* where_opt ::= */ yytestcase(yyruleno==170);
       case 232: /* case_else ::= */ yytestcase(yyruleno==232);
       case 234: /* case_operand ::= */ yytestcase(yyruleno==234);
 {yygotominor.yy132 = 0;}
         break;
       case 148: /* indexed_opt ::= NOT INDEXED */
       case 151: /* indexed_opt ::= NOT INDEXED */
 {yygotominor.yy0.z=0; yygotominor.yy0.n=1;}
         break;
       case 149: /* using_opt ::= USING LP inscollist RP */
       case 180: /* inscollist_opt ::= LP inscollist RP */ yytestcase(yyruleno==180);
 {yygotominor.yy180 = yymsp[-1].minor.yy180;}
       case 152: /* using_opt ::= USING LP idlist RP */
       case 180: /* inscollist_opt ::= LP idlist RP */ yytestcase(yyruleno==180);
 {yygotominor.yy408 = yymsp[-1].minor.yy408;}
         break;
       case 150: /* using_opt ::= */
       case 153: /* using_opt ::= */
       case 179: /* inscollist_opt ::= */ yytestcase(yyruleno==179);
 {yygotominor.yy180 = 0;}
 {yygotominor.yy408 = 0;}
         break;
       case 152: /* orderby_opt ::= ORDER BY sortlist */
       case 159: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==159);
       case 238: /* exprlist ::= nexprlist */ yytestcase(yyruleno==238);
 {yygotominor.yy442 = yymsp[0].minor.yy442;}
       case 155: /* orderby_opt ::= ORDER BY sortlist */
       case 162: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==162);
       case 235: /* exprlist ::= nexprlist */ yytestcase(yyruleno==235);
 {yygotominor.yy14 = yymsp[0].minor.yy14;}
         break;
       case 153: /* sortlist ::= sortlist COMMA expr sortorder */
       case 156: /* sortlist ::= sortlist COMMA expr sortorder */
 {
   yygotominor.yy442 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy442,yymsp[-1].minor.yy342.pExpr);
   if( yygotominor.yy442 ) yygotominor.yy442->a[yygotominor.yy442->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy392;
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14,yymsp[-1].minor.yy346.pExpr);
   if( yygotominor.yy14 ) yygotominor.yy14->a[yygotominor.yy14->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy328;
 }
         break;
       case 154: /* sortlist ::= expr sortorder */
       case 157: /* sortlist ::= expr sortorder */
 {
   yygotominor.yy442 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy342.pExpr);
   if( yygotominor.yy442 && ALWAYS(yygotominor.yy442->a) ) yygotominor.yy442->a[0].sortOrder = (u8)yymsp[0].minor.yy392;
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy346.pExpr);
   if( yygotominor.yy14 && ALWAYS(yygotominor.yy14->a) ) yygotominor.yy14->a[0].sortOrder = (u8)yymsp[0].minor.yy328;
 }
         break;
       case 155: /* sortorder ::= ASC */
       case 157: /* sortorder ::= */ yytestcase(yyruleno==157);
 {yygotominor.yy392 = SQLITE_SO_ASC;}
       case 158: /* sortorder ::= ASC */
       case 160: /* sortorder ::= */ yytestcase(yyruleno==160);
 {yygotominor.yy328 = SQLITE_SO_ASC;}
         break;
       case 156: /* sortorder ::= DESC */
 {yygotominor.yy392 = SQLITE_SO_DESC;}
       case 159: /* sortorder ::= DESC */
 {yygotominor.yy328 = SQLITE_SO_DESC;}
         break;
       case 162: /* limit_opt ::= */
 {yygotominor.yy64.pLimit = 0; yygotominor.yy64.pOffset = 0;}
       case 165: /* limit_opt ::= */
 {yygotominor.yy476.pLimit = 0; yygotominor.yy476.pOffset = 0;}
         break;
       case 163: /* limit_opt ::= LIMIT expr */
 {yygotominor.yy64.pLimit = yymsp[0].minor.yy342.pExpr; yygotominor.yy64.pOffset = 0;}
       case 166: /* limit_opt ::= LIMIT expr */
 {yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr; yygotominor.yy476.pOffset = 0;}
         break;
       case 164: /* limit_opt ::= LIMIT expr OFFSET expr */
 {yygotominor.yy64.pLimit = yymsp[-2].minor.yy342.pExpr; yygotominor.yy64.pOffset = yymsp[0].minor.yy342.pExpr;}
       case 167: /* limit_opt ::= LIMIT expr OFFSET expr */
 {yygotominor.yy476.pLimit = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pOffset = yymsp[0].minor.yy346.pExpr;}
         break;
       case 165: /* limit_opt ::= LIMIT expr COMMA expr */
 {yygotominor.yy64.pOffset = yymsp[-2].minor.yy342.pExpr; yygotominor.yy64.pLimit = yymsp[0].minor.yy342.pExpr;}
       case 168: /* limit_opt ::= LIMIT expr COMMA expr */
 {yygotominor.yy476.pOffset = yymsp[-2].minor.yy346.pExpr; yygotominor.yy476.pLimit = yymsp[0].minor.yy346.pExpr;}
         break;
       case 166: /* cmd ::= DELETE FROM fullname indexed_opt where_opt */
       case 169: /* cmd ::= with DELETE FROM fullname indexed_opt where_opt */
 {
   sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy347, &yymsp[-1].minor.yy0);
   sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy347,yymsp[0].minor.yy122);
   sqlite3WithPush(pParse, yymsp[-5].minor.yy59, 1);
   sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy65, &yymsp[-1].minor.yy0);
   sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy65,yymsp[0].minor.yy132);
 }
         break;
       case 169: /* cmd ::= UPDATE orconf fullname indexed_opt SET setlist where_opt */
       case 172: /* cmd ::= with UPDATE orconf fullname indexed_opt SET setlist where_opt */
 {
   sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy347, &yymsp[-3].minor.yy0);
   sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy442,"set list");
   sqlite3Update(pParse,yymsp[-4].minor.yy347,yymsp[-1].minor.yy442,yymsp[0].minor.yy122,yymsp[-5].minor.yy258);
   sqlite3WithPush(pParse, yymsp[-7].minor.yy59, 1);
   sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy65, &yymsp[-3].minor.yy0);
   sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy14,"set list");
   sqlite3Update(pParse,yymsp[-4].minor.yy65,yymsp[-1].minor.yy14,yymsp[0].minor.yy132,yymsp[-5].minor.yy186);
 }
         break;
       case 170: /* setlist ::= setlist COMMA nm EQ expr */
       case 173: /* setlist ::= setlist COMMA nm EQ expr */
 {
   yygotominor.yy442 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy442, yymsp[0].minor.yy342.pExpr);
   sqlite3ExprListSetName(pParse, yygotominor.yy442, &yymsp[-2].minor.yy0, 1);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy346.pExpr);
   sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
 }
         break;
       case 171: /* setlist ::= nm EQ expr */
       case 174: /* setlist ::= nm EQ expr */
 {
   yygotominor.yy442 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy342.pExpr);
   sqlite3ExprListSetName(pParse, yygotominor.yy442, &yymsp[-2].minor.yy0, 1);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy346.pExpr);
   sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
 }
         break;
       case 172: /* cmd ::= insert_cmd INTO fullname inscollist_opt valuelist */
 {sqlite3Insert(pParse, yymsp[-2].minor.yy347, yymsp[0].minor.yy487.pList, yymsp[0].minor.yy487.pSelect, yymsp[-1].minor.yy180, yymsp[-4].minor.yy258);}
         break;
       case 173: /* cmd ::= insert_cmd INTO fullname inscollist_opt select */
 {sqlite3Insert(pParse, yymsp[-2].minor.yy347, 0, yymsp[0].minor.yy159, yymsp[-1].minor.yy180, yymsp[-4].minor.yy258);}
         break;
       case 174: /* cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES */
 {sqlite3Insert(pParse, yymsp[-3].minor.yy347, 0, 0, yymsp[-2].minor.yy180, yymsp[-5].minor.yy258);}
         break;
       case 175: /* insert_cmd ::= INSERT orconf */
 {yygotominor.yy258 = yymsp[0].minor.yy258;}
         break;
       case 176: /* insert_cmd ::= REPLACE */
 {yygotominor.yy258 = OE_Replace;}
         break;
       case 177: /* valuelist ::= VALUES LP nexprlist RP */
       case 175: /* cmd ::= with insert_cmd INTO fullname inscollist_opt select */
 {
   yygotominor.yy487.pList = yymsp[-1].minor.yy442;
   yygotominor.yy487.pSelect = 0;
   sqlite3WithPush(pParse, yymsp[-5].minor.yy59, 1);
   sqlite3Insert(pParse, yymsp[-2].minor.yy65, yymsp[0].minor.yy3, yymsp[-1].minor.yy408, yymsp[-4].minor.yy186);
 }
         break;
       case 178: /* valuelist ::= valuelist COMMA LP exprlist RP */
       case 176: /* cmd ::= with insert_cmd INTO fullname inscollist_opt DEFAULT VALUES */
 {
   Select *pRight = sqlite3SelectNew(pParse, yymsp[-1].minor.yy442, 0, 0, 0, 0, 0, 0, 0, 0);
   if( yymsp[-4].minor.yy487.pList ){
     yymsp[-4].minor.yy487.pSelect = sqlite3SelectNew(pParse, yymsp[-4].minor.yy487.pList, 0, 0, 0, 0, 0, 0, 0, 0);
     yymsp[-4].minor.yy487.pList = 0;
   }
   yygotominor.yy487.pList = 0;
   if( yymsp[-4].minor.yy487.pSelect==0 || pRight==0 ){
     sqlite3SelectDelete(pParse->db, pRight);
     sqlite3SelectDelete(pParse->db, yymsp[-4].minor.yy487.pSelect);
     yygotominor.yy487.pSelect = 0;
   }else{
     pRight->op = TK_ALL;
     pRight->pPrior = yymsp[-4].minor.yy487.pSelect;
     pRight->selFlags |= SF_Values;
     pRight->pPrior->selFlags |= SF_Values;
     yygotominor.yy487.pSelect = pRight;
   }
   sqlite3WithPush(pParse, yymsp[-6].minor.yy59, 1);
   sqlite3Insert(pParse, yymsp[-3].minor.yy65, 0, yymsp[-2].minor.yy408, yymsp[-5].minor.yy186);
 }
         break;
       case 181: /* inscollist ::= inscollist COMMA nm */
 {yygotominor.yy180 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy180,&yymsp[0].minor.yy0);}
       case 177: /* insert_cmd ::= INSERT orconf */
 {yygotominor.yy186 = yymsp[0].minor.yy186;}
         break;
       case 178: /* insert_cmd ::= REPLACE */
 {yygotominor.yy186 = OE_Replace;}
         break;
       case 181: /* idlist ::= idlist COMMA nm */
 {yygotominor.yy408 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy408,&yymsp[0].minor.yy0);}
         break;
       case 182: /* inscollist ::= nm */
 {yygotominor.yy180 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
       case 182: /* idlist ::= nm */
 {yygotominor.yy408 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
         break;
       case 183: /* expr ::= term */
 {yygotominor.yy342 = yymsp[0].minor.yy342;}
 {yygotominor.yy346 = yymsp[0].minor.yy346;}
         break;
       case 184: /* expr ::= LP expr RP */
 {yygotominor.yy342.pExpr = yymsp[-1].minor.yy342.pExpr; spanSet(&yygotominor.yy342,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
 {yygotominor.yy346.pExpr = yymsp[-1].minor.yy346.pExpr; spanSet(&yygotominor.yy346,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
         break;
       case 185: /* term ::= NULL */
       case 190: /* term ::= INTEGER|FLOAT|BLOB */ yytestcase(yyruleno==190);
       case 191: /* term ::= STRING */ yytestcase(yyruleno==191);
 {spanExpr(&yygotominor.yy342, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
 {spanExpr(&yygotominor.yy346, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
         break;
       case 186: /* expr ::= id */
       case 186: /* expr ::= ID|INDEXED */
       case 187: /* expr ::= JOIN_KW */ yytestcase(yyruleno==187);
 {spanExpr(&yygotominor.yy342, pParse, TK_ID, &yymsp[0].minor.yy0);}
 {spanExpr(&yygotominor.yy346, pParse, TK_ID, &yymsp[0].minor.yy0);}
         break;
       case 188: /* expr ::= nm DOT nm */
 {
   Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
   Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
   yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
   spanSet(&yygotominor.yy342,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
   yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
   spanSet(&yygotominor.yy346,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
 }
         break;
       case 189: /* expr ::= nm DOT nm DOT nm */

@@ -115483,163 +118058,154 @@ static void yy_reduce(

   Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
   Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
   Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
   yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
   spanSet(&yygotominor.yy342,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
   yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
   spanSet(&yygotominor.yy346,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
 }
         break;
       case 192: /* expr ::= REGISTER */
       case 192: /* expr ::= VARIABLE */
 {
   /* When doing a nested parse, one can include terms in an expression
   ** that look like this:   #1 #2 ...  These terms refer to registers
   ** in the virtual machine.  #N is the N-th register. */
   if( pParse->nested==0 ){
     sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0);
     yygotominor.yy342.pExpr = 0;
   if( yymsp[0].minor.yy0.n>=2 && yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1]) ){
     /* When doing a nested parse, one can include terms in an expression
     ** that look like this:   #1 #2 ...  These terms refer to registers
     ** in the virtual machine.  #N is the N-th register. */
     if( pParse->nested==0 ){
       sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0);
       yygotominor.yy346.pExpr = 0;
     }else{
       yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
       if( yygotominor.yy346.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy346.pExpr->iTable);
     }
   }else{
     yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
     if( yygotominor.yy342.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy342.pExpr->iTable);
     spanExpr(&yygotominor.yy346, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
     sqlite3ExprAssignVarNumber(pParse, yygotominor.yy346.pExpr);
   }
   spanSet(&yygotominor.yy342, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
   spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
 }
         break;
       case 193: /* expr ::= VARIABLE */
       case 193: /* expr ::= expr COLLATE ID|STRING */
 {
   spanExpr(&yygotominor.yy342, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
   sqlite3ExprAssignVarNumber(pParse, yygotominor.yy342.pExpr);
   spanSet(&yygotominor.yy342, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
   yygotominor.yy346.pExpr = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy346.pExpr, &yymsp[0].minor.yy0);
   yygotominor.yy346.zStart = yymsp[-2].minor.yy346.zStart;
   yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
 }
         break;
       case 194: /* expr ::= expr COLLATE ids */
       case 194: /* expr ::= CAST LP expr AS typetoken RP */
 {
   yygotominor.yy342.pExpr = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy342.pExpr, &yymsp[0].minor.yy0);
   yygotominor.yy342.zStart = yymsp[-2].minor.yy342.zStart;
   yygotominor.yy342.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
   yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy346.pExpr, 0, &yymsp[-1].minor.yy0);
   spanSet(&yygotominor.yy346,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);
 }
         break;
       case 195: /* expr ::= CAST LP expr AS typetoken RP */
       case 195: /* expr ::= ID|INDEXED LP distinct exprlist RP */
 {
   yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy342.pExpr, 0, &yymsp[-1].minor.yy0);
   spanSet(&yygotominor.yy342,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);
 }
         break;
       case 196: /* expr ::= ID LP distinct exprlist RP */
 {
   if( yymsp[-1].minor.yy442 && yymsp[-1].minor.yy442->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
   if( yymsp[-1].minor.yy14 && yymsp[-1].minor.yy14->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
     sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0);
   }
   yygotominor.yy342.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy442, &yymsp[-4].minor.yy0);
   spanSet(&yygotominor.yy342,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
   if( yymsp[-2].minor.yy305 && yygotominor.yy342.pExpr ){
     yygotominor.yy342.pExpr->flags |= EP_Distinct;
   yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
   spanSet(&yygotominor.yy346,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
   if( yymsp[-2].minor.yy381 && yygotominor.yy346.pExpr ){
     yygotominor.yy346.pExpr->flags |= EP_Distinct;
   }
 }
         break;
       case 197: /* expr ::= ID LP STAR RP */
       case 196: /* expr ::= ID|INDEXED LP STAR RP */
 {
   yygotominor.yy342.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
   spanSet(&yygotominor.yy342,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
   yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
   spanSet(&yygotominor.yy346,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
 }
         break;
       case 198: /* term ::= CTIME_KW */
       case 197: /* term ::= CTIME_KW */
 {
   /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
   ** treated as functions that return constants */
   yygotominor.yy342.pExpr = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
   if( yygotominor.yy342.pExpr ){
     yygotominor.yy342.pExpr->op = TK_CONST_FUNC;
   }
   spanSet(&yygotominor.yy342, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
   yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0);
   spanSet(&yygotominor.yy346, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
 }
         break;
       case 199: /* expr ::= expr AND expr */
       case 200: /* expr ::= expr OR expr */ yytestcase(yyruleno==200);
       case 201: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==201);
       case 202: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==202);
       case 203: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==203);
       case 204: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==204);
       case 205: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==205);
       case 206: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==206);
 {spanBinaryExpr(&yygotominor.yy342,pParse,yymsp[-1].major,&yymsp[-2].minor.yy342,&yymsp[0].minor.yy342);}
       case 198: /* expr ::= expr AND expr */
       case 199: /* expr ::= expr OR expr */ yytestcase(yyruleno==199);
       case 200: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==200);
       case 201: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==201);
       case 202: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==202);
       case 203: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==203);
       case 204: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==204);
       case 205: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==205);
 {spanBinaryExpr(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346);}
         break;
       case 207: /* likeop ::= LIKE_KW */
       case 209: /* likeop ::= MATCH */ yytestcase(yyruleno==209);
 {yygotominor.yy318.eOperator = yymsp[0].minor.yy0; yygotominor.yy318.bNot = 0;}
       case 206: /* likeop ::= LIKE_KW|MATCH */
 {yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.bNot = 0;}
         break;
       case 208: /* likeop ::= NOT LIKE_KW */
       case 210: /* likeop ::= NOT MATCH */ yytestcase(yyruleno==210);
 {yygotominor.yy318.eOperator = yymsp[0].minor.yy0; yygotominor.yy318.bNot = 1;}
       case 207: /* likeop ::= NOT LIKE_KW|MATCH */
 {yygotominor.yy96.eOperator = yymsp[0].minor.yy0; yygotominor.yy96.bNot = 1;}
         break;
       case 211: /* expr ::= expr likeop expr */
       case 208: /* expr ::= expr likeop expr */
 {
   ExprList *pList;
   pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy342.pExpr);
   pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy342.pExpr);
   yygotominor.yy342.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy318.eOperator);
   if( yymsp[-1].minor.yy318.bNot ) yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy342.pExpr, 0, 0);
   yygotominor.yy342.zStart = yymsp[-2].minor.yy342.zStart;
   yygotominor.yy342.zEnd = yymsp[0].minor.yy342.zEnd;
   if( yygotominor.yy342.pExpr ) yygotominor.yy342.pExpr->flags |= EP_InfixFunc;
   pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy346.pExpr);
   pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy346.pExpr);
   yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy96.eOperator);
   if( yymsp[-1].minor.yy96.bNot ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
   yygotominor.yy346.zStart = yymsp[-2].minor.yy346.zStart;
   yygotominor.yy346.zEnd = yymsp[0].minor.yy346.zEnd;
   if( yygotominor.yy346.pExpr ) yygotominor.yy346.pExpr->flags |= EP_InfixFunc;
 }
         break;
       case 212: /* expr ::= expr likeop expr ESCAPE expr */
       case 209: /* expr ::= expr likeop expr ESCAPE expr */
 {
   ExprList *pList;
   pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy342.pExpr);
   pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy342.pExpr);
   pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy342.pExpr);
   yygotominor.yy342.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy318.eOperator);
   if( yymsp[-3].minor.yy318.bNot ) yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy342.pExpr, 0, 0);
   yygotominor.yy342.zStart = yymsp[-4].minor.yy342.zStart;
   yygotominor.yy342.zEnd = yymsp[0].minor.yy342.zEnd;
   if( yygotominor.yy342.pExpr ) yygotominor.yy342.pExpr->flags |= EP_InfixFunc;
   pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
   pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy346.pExpr);
   pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
   yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy96.eOperator);
   if( yymsp[-3].minor.yy96.bNot ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
   yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
   yygotominor.yy346.zEnd = yymsp[0].minor.yy346.zEnd;
   if( yygotominor.yy346.pExpr ) yygotominor.yy346.pExpr->flags |= EP_InfixFunc;
 }
         break;
       case 213: /* expr ::= expr ISNULL|NOTNULL */
 {spanUnaryPostfix(&yygotominor.yy342,pParse,yymsp[0].major,&yymsp[-1].minor.yy342,&yymsp[0].minor.yy0);}
       case 210: /* expr ::= expr ISNULL|NOTNULL */
 {spanUnaryPostfix(&yygotominor.yy346,pParse,yymsp[0].major,&yymsp[-1].minor.yy346,&yymsp[0].minor.yy0);}
         break;
       case 214: /* expr ::= expr NOT NULL */
 {spanUnaryPostfix(&yygotominor.yy342,pParse,TK_NOTNULL,&yymsp[-2].minor.yy342,&yymsp[0].minor.yy0);}
       case 211: /* expr ::= expr NOT NULL */
 {spanUnaryPostfix(&yygotominor.yy346,pParse,TK_NOTNULL,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy0);}
         break;
       case 215: /* expr ::= expr IS expr */
       case 212: /* expr ::= expr IS expr */
 {
   spanBinaryExpr(&yygotominor.yy342,pParse,TK_IS,&yymsp[-2].minor.yy342,&yymsp[0].minor.yy342);
   binaryToUnaryIfNull(pParse, yymsp[0].minor.yy342.pExpr, yygotominor.yy342.pExpr, TK_ISNULL);
   spanBinaryExpr(&yygotominor.yy346,pParse,TK_IS,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346);
   binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_ISNULL);
 }
         break;
       case 216: /* expr ::= expr IS NOT expr */
       case 213: /* expr ::= expr IS NOT expr */
 {
   spanBinaryExpr(&yygotominor.yy342,pParse,TK_ISNOT,&yymsp[-3].minor.yy342,&yymsp[0].minor.yy342);
   binaryToUnaryIfNull(pParse, yymsp[0].minor.yy342.pExpr, yygotominor.yy342.pExpr, TK_NOTNULL);
   spanBinaryExpr(&yygotominor.yy346,pParse,TK_ISNOT,&yymsp[-3].minor.yy346,&yymsp[0].minor.yy346);
   binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_NOTNULL);
 }
         break;
       case 217: /* expr ::= NOT expr */
       case 218: /* expr ::= BITNOT expr */ yytestcase(yyruleno==218);
 {spanUnaryPrefix(&yygotominor.yy342,pParse,yymsp[-1].major,&yymsp[0].minor.yy342,&yymsp[-1].minor.yy0);}
       case 214: /* expr ::= NOT expr */
       case 215: /* expr ::= BITNOT expr */ yytestcase(yyruleno==215);
 {spanUnaryPrefix(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
         break;
       case 219: /* expr ::= MINUS expr */
 {spanUnaryPrefix(&yygotominor.yy342,pParse,TK_UMINUS,&yymsp[0].minor.yy342,&yymsp[-1].minor.yy0);}
       case 216: /* expr ::= MINUS expr */
 {spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UMINUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
         break;
       case 220: /* expr ::= PLUS expr */
 {spanUnaryPrefix(&yygotominor.yy342,pParse,TK_UPLUS,&yymsp[0].minor.yy342,&yymsp[-1].minor.yy0);}
       case 217: /* expr ::= PLUS expr */
 {spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UPLUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
         break;
       case 223: /* expr ::= expr between_op expr AND expr */
       case 220: /* expr ::= expr between_op expr AND expr */
 {
   ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy342.pExpr);
   pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy342.pExpr);
   yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy342.pExpr, 0, 0);
   if( yygotominor.yy342.pExpr ){
     yygotominor.yy342.pExpr->x.pList = pList;
   ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
   pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
   yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy346.pExpr, 0, 0);
   if( yygotominor.yy346.pExpr ){
     yygotominor.yy346.pExpr->x.pList = pList;
   }else{
     sqlite3ExprListDelete(pParse->db, pList);
   }
   if( yymsp[-3].minor.yy392 ) yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy342.pExpr, 0, 0);
   yygotominor.yy342.zStart = yymsp[-4].minor.yy342.zStart;
   yygotominor.yy342.zEnd = yymsp[0].minor.yy342.zEnd;
   if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
   yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
   yygotominor.yy346.zEnd = yymsp[0].minor.yy346.zEnd;
 }
         break;
       case 226: /* expr ::= expr in_op LP exprlist RP */
       case 223: /* expr ::= expr in_op LP exprlist RP */
 {
     if( yymsp[-1].minor.yy442==0 ){
     if( yymsp[-1].minor.yy14==0 ){
       /* Expressions of the form
       **
       **      expr1 IN ()

@@ -115648,225 +118214,225 @@ static void yy_reduce(

       ** simplify to constants 0 (false) and 1 (true), respectively,
       ** regardless of the value of expr1.
       */
       yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[yymsp[-3].minor.yy392]);
       sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy342.pExpr);
       yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[yymsp[-3].minor.yy328]);
       sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy346.pExpr);
     }else{
       yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy342.pExpr, 0, 0);
       if( yygotominor.yy342.pExpr ){
         yygotominor.yy342.pExpr->x.pList = yymsp[-1].minor.yy442;
         sqlite3ExprSetHeight(pParse, yygotominor.yy342.pExpr);
       yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
       if( yygotominor.yy346.pExpr ){
         yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy14;
         sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
       }else{
         sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy442);
         sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
       }
       if( yymsp[-3].minor.yy392 ) yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy342.pExpr, 0, 0);
       if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
     }
     yygotominor.yy342.zStart = yymsp[-4].minor.yy342.zStart;
     yygotominor.yy342.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
     yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
     yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
   }
         break;
       case 227: /* expr ::= LP select RP */
       case 224: /* expr ::= LP select RP */
 {
     yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
     if( yygotominor.yy342.pExpr ){
       yygotominor.yy342.pExpr->x.pSelect = yymsp[-1].minor.yy159;
       ExprSetProperty(yygotominor.yy342.pExpr, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, yygotominor.yy342.pExpr);
     yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
     if( yygotominor.yy346.pExpr ){
       yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
       ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
     }else{
       sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy159);
       sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
     }
     yygotominor.yy342.zStart = yymsp[-2].minor.yy0.z;
     yygotominor.yy342.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
     yygotominor.yy346.zStart = yymsp[-2].minor.yy0.z;
     yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
   }
         break;
       case 228: /* expr ::= expr in_op LP select RP */
       case 225: /* expr ::= expr in_op LP select RP */
 {
     yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy342.pExpr, 0, 0);
     if( yygotominor.yy342.pExpr ){
       yygotominor.yy342.pExpr->x.pSelect = yymsp[-1].minor.yy159;
       ExprSetProperty(yygotominor.yy342.pExpr, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, yygotominor.yy342.pExpr);
     yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
     if( yygotominor.yy346.pExpr ){
       yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
       ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
     }else{
       sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy159);
       sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
     }
     if( yymsp[-3].minor.yy392 ) yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy342.pExpr, 0, 0);
     yygotominor.yy342.zStart = yymsp[-4].minor.yy342.zStart;
     yygotominor.yy342.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
     if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
     yygotominor.yy346.zStart = yymsp[-4].minor.yy346.zStart;
     yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
   }
         break;
       case 229: /* expr ::= expr in_op nm dbnm */
       case 226: /* expr ::= expr in_op nm dbnm */
 {
     SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);
     yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy342.pExpr, 0, 0);
     if( yygotominor.yy342.pExpr ){
       yygotominor.yy342.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
       ExprSetProperty(yygotominor.yy342.pExpr, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, yygotominor.yy342.pExpr);
     yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy346.pExpr, 0, 0);
     if( yygotominor.yy346.pExpr ){
       yygotominor.yy346.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
       ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
     }else{
       sqlite3SrcListDelete(pParse->db, pSrc);
     }
     if( yymsp[-2].minor.yy392 ) yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy342.pExpr, 0, 0);
     yygotominor.yy342.zStart = yymsp[-3].minor.yy342.zStart;
     yygotominor.yy342.zEnd = yymsp[0].minor.yy0.z ? &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] : &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n];
     if( yymsp[-2].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
     yygotominor.yy346.zStart = yymsp[-3].minor.yy346.zStart;
     yygotominor.yy346.zEnd = yymsp[0].minor.yy0.z ? &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] : &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n];
   }
         break;
       case 230: /* expr ::= EXISTS LP select RP */
       case 227: /* expr ::= EXISTS LP select RP */
 {
     Expr *p = yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
     Expr *p = yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
     if( p ){
       p->x.pSelect = yymsp[-1].minor.yy159;
       p->x.pSelect = yymsp[-1].minor.yy3;
       ExprSetProperty(p, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, p);
     }else{
       sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy159);
       sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
     }
     yygotominor.yy342.zStart = yymsp[-3].minor.yy0.z;
     yygotominor.yy342.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
     yygotominor.yy346.zStart = yymsp[-3].minor.yy0.z;
     yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
   }
         break;
       case 231: /* expr ::= CASE case_operand case_exprlist case_else END */
       case 228: /* expr ::= CASE case_operand case_exprlist case_else END */
 {
   yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy122, 0, 0);
   if( yygotominor.yy342.pExpr ){
     yygotominor.yy342.pExpr->x.pList = yymsp[-1].minor.yy122 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy442,yymsp[-1].minor.yy122) : yymsp[-2].minor.yy442;
     sqlite3ExprSetHeight(pParse, yygotominor.yy342.pExpr);
   yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy132, 0, 0);
   if( yygotominor.yy346.pExpr ){
     yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy132 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy132) : yymsp[-2].minor.yy14;
     sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
   }else{
     sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy442);
     sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy122);
     sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
     sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy132);
   }
   yygotominor.yy342.zStart = yymsp[-4].minor.yy0.z;
   yygotominor.yy342.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
   yygotominor.yy346.zStart = yymsp[-4].minor.yy0.z;
   yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
 }
         break;
       case 232: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
       case 229: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
 {
   yygotominor.yy442 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy442, yymsp[-2].minor.yy342.pExpr);
   yygotominor.yy442 = sqlite3ExprListAppend(pParse,yygotominor.yy442, yymsp[0].minor.yy342.pExpr);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy346.pExpr);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
 }
         break;
       case 233: /* case_exprlist ::= WHEN expr THEN expr */
       case 230: /* case_exprlist ::= WHEN expr THEN expr */
 {
   yygotominor.yy442 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy342.pExpr);
   yygotominor.yy442 = sqlite3ExprListAppend(pParse,yygotominor.yy442, yymsp[0].minor.yy342.pExpr);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
 }
         break;
       case 240: /* nexprlist ::= nexprlist COMMA expr */
 {yygotominor.yy442 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy442,yymsp[0].minor.yy342.pExpr);}
       case 237: /* nexprlist ::= nexprlist COMMA expr */
 {yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy346.pExpr);}
         break;
       case 241: /* nexprlist ::= expr */
 {yygotominor.yy442 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy342.pExpr);}
       case 238: /* nexprlist ::= expr */
 {yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy346.pExpr);}
         break;
       case 242: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP where_opt */
       case 239: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP where_opt */
 {
   sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
                      sqlite3SrcListAppend(pParse->db,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy442, yymsp[-10].minor.yy392,
                       &yymsp[-11].minor.yy0, yymsp[0].minor.yy122, SQLITE_SO_ASC, yymsp[-8].minor.yy392);
                      sqlite3SrcListAppend(pParse->db,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy328,
                       &yymsp[-11].minor.yy0, yymsp[0].minor.yy132, SQLITE_SO_ASC, yymsp[-8].minor.yy328);
 }
         break;
       case 243: /* uniqueflag ::= UNIQUE */
       case 296: /* raisetype ::= ABORT */ yytestcase(yyruleno==296);
 {yygotominor.yy392 = OE_Abort;}
       case 240: /* uniqueflag ::= UNIQUE */
       case 291: /* raisetype ::= ABORT */ yytestcase(yyruleno==291);
 {yygotominor.yy328 = OE_Abort;}
         break;
       case 244: /* uniqueflag ::= */
 {yygotominor.yy392 = OE_None;}
       case 241: /* uniqueflag ::= */
 {yygotominor.yy328 = OE_None;}
         break;
       case 247: /* idxlist ::= idxlist COMMA nm collate sortorder */
       case 244: /* idxlist ::= idxlist COMMA nm collate sortorder */
 {
   Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0);
   yygotominor.yy442 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy442, p);
   sqlite3ExprListSetName(pParse,yygotominor.yy442,&yymsp[-2].minor.yy0,1);
   sqlite3ExprListCheckLength(pParse, yygotominor.yy442, "index");
   if( yygotominor.yy442 ) yygotominor.yy442->a[yygotominor.yy442->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy392;
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, p);
   sqlite3ExprListSetName(pParse,yygotominor.yy14,&yymsp[-2].minor.yy0,1);
   sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");
   if( yygotominor.yy14 ) yygotominor.yy14->a[yygotominor.yy14->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy328;
 }
         break;
       case 248: /* idxlist ::= nm collate sortorder */
       case 245: /* idxlist ::= nm collate sortorder */
 {
   Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0);
   yygotominor.yy442 = sqlite3ExprListAppend(pParse,0, p);
   sqlite3ExprListSetName(pParse, yygotominor.yy442, &yymsp[-2].minor.yy0, 1);
   sqlite3ExprListCheckLength(pParse, yygotominor.yy442, "index");
   if( yygotominor.yy442 ) yygotominor.yy442->a[yygotominor.yy442->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy392;
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, p);
   sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
   sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");
   if( yygotominor.yy14 ) yygotominor.yy14->a[yygotominor.yy14->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy328;
 }
         break;
       case 249: /* collate ::= */
       case 246: /* collate ::= */
 {yygotominor.yy0.z = 0; yygotominor.yy0.n = 0;}
         break;
       case 251: /* cmd ::= DROP INDEX ifexists fullname */
 {sqlite3DropIndex(pParse, yymsp[0].minor.yy347, yymsp[-1].minor.yy392);}
       case 248: /* cmd ::= DROP INDEX ifexists fullname */
 {sqlite3DropIndex(pParse, yymsp[0].minor.yy65, yymsp[-1].minor.yy328);}
         break;
       case 252: /* cmd ::= VACUUM */
       case 253: /* cmd ::= VACUUM nm */ yytestcase(yyruleno==253);
       case 249: /* cmd ::= VACUUM */
       case 250: /* cmd ::= VACUUM nm */ yytestcase(yyruleno==250);
 {sqlite3Vacuum(pParse);}
         break;
       case 254: /* cmd ::= PRAGMA nm dbnm */
       case 251: /* cmd ::= PRAGMA nm dbnm */
 {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
         break;
       case 255: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
       case 252: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
         break;
       case 256: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
       case 253: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
         break;
       case 257: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
       case 254: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
         break;
       case 258: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
       case 255: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
         break;
       case 268: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
       case 264: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
 {
   Token all;
   all.z = yymsp[-3].minor.yy0.z;
   all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
   sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy327, &all);
   sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy473, &all);
 }
         break;
       case 269: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
       case 265: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
 {
   sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy392, yymsp[-4].minor.yy410.a, yymsp[-4].minor.yy410.b, yymsp[-2].minor.yy347, yymsp[0].minor.yy122, yymsp[-10].minor.yy392, yymsp[-8].minor.yy392);
   sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy328, yymsp[-4].minor.yy378.a, yymsp[-4].minor.yy378.b, yymsp[-2].minor.yy65, yymsp[0].minor.yy132, yymsp[-10].minor.yy328, yymsp[-8].minor.yy328);
   yygotominor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0);
 }
         break;
       case 270: /* trigger_time ::= BEFORE */
       case 273: /* trigger_time ::= */ yytestcase(yyruleno==273);
 { yygotominor.yy392 = TK_BEFORE; }
       case 266: /* trigger_time ::= BEFORE */
       case 269: /* trigger_time ::= */ yytestcase(yyruleno==269);
 { yygotominor.yy328 = TK_BEFORE; }
         break;
       case 271: /* trigger_time ::= AFTER */
 { yygotominor.yy392 = TK_AFTER;  }
       case 267: /* trigger_time ::= AFTER */
 { yygotominor.yy328 = TK_AFTER;  }
         break;
       case 272: /* trigger_time ::= INSTEAD OF */
 { yygotominor.yy392 = TK_INSTEAD;}
       case 268: /* trigger_time ::= INSTEAD OF */
 { yygotominor.yy328 = TK_INSTEAD;}
         break;
       case 274: /* trigger_event ::= DELETE|INSERT */
       case 275: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==275);
 {yygotominor.yy410.a = yymsp[0].major; yygotominor.yy410.b = 0;}
       case 270: /* trigger_event ::= DELETE|INSERT */
       case 271: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==271);
 {yygotominor.yy378.a = yymsp[0].major; yygotominor.yy378.b = 0;}
         break;
       case 276: /* trigger_event ::= UPDATE OF inscollist */
 {yygotominor.yy410.a = TK_UPDATE; yygotominor.yy410.b = yymsp[0].minor.yy180;}
       case 272: /* trigger_event ::= UPDATE OF idlist */
 {yygotominor.yy378.a = TK_UPDATE; yygotominor.yy378.b = yymsp[0].minor.yy408;}
         break;
       case 279: /* when_clause ::= */
       case 301: /* key_opt ::= */ yytestcase(yyruleno==301);
 { yygotominor.yy122 = 0; }
       case 275: /* when_clause ::= */
       case 296: /* key_opt ::= */ yytestcase(yyruleno==296);
 { yygotominor.yy132 = 0; }
         break;
       case 280: /* when_clause ::= WHEN expr */
       case 302: /* key_opt ::= KEY expr */ yytestcase(yyruleno==302);
 { yygotominor.yy122 = yymsp[0].minor.yy342.pExpr; }
       case 276: /* when_clause ::= WHEN expr */
       case 297: /* key_opt ::= KEY expr */ yytestcase(yyruleno==297);
 { yygotominor.yy132 = yymsp[0].minor.yy346.pExpr; }
         break;
       case 281: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
       case 277: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
 {
   assert( yymsp[-2].minor.yy327!=0 );
   yymsp[-2].minor.yy327->pLast->pNext = yymsp[-1].minor.yy327;
   yymsp[-2].minor.yy327->pLast = yymsp[-1].minor.yy327;
   yygotominor.yy327 = yymsp[-2].minor.yy327;
   assert( yymsp[-2].minor.yy473!=0 );
   yymsp[-2].minor.yy473->pLast->pNext = yymsp[-1].minor.yy473;
   yymsp[-2].minor.yy473->pLast = yymsp[-1].minor.yy473;
   yygotominor.yy473 = yymsp[-2].minor.yy473;
 }
         break;
       case 282: /* trigger_cmd_list ::= trigger_cmd SEMI */
       case 278: /* trigger_cmd_list ::= trigger_cmd SEMI */
 {
   assert( yymsp[-1].minor.yy327!=0 );
   yymsp[-1].minor.yy327->pLast = yymsp[-1].minor.yy327;
   yygotominor.yy327 = yymsp[-1].minor.yy327;
   assert( yymsp[-1].minor.yy473!=0 );
   yymsp[-1].minor.yy473->pLast = yymsp[-1].minor.yy473;
   yygotominor.yy473 = yymsp[-1].minor.yy473;
 }
         break;
       case 284: /* trnm ::= nm DOT nm */
       case 280: /* trnm ::= nm DOT nm */
 {
   yygotominor.yy0 = yymsp[0].minor.yy0;
   sqlite3ErrorMsg(pParse,

@@ -115874,123 +118440,137 @@ static void yy_reduce(

         "statements within triggers");
 }
         break;
       case 286: /* tridxby ::= INDEXED BY nm */
       case 282: /* tridxby ::= INDEXED BY nm */
 {
   sqlite3ErrorMsg(pParse,
         "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
         "within triggers");
 }
         break;
       case 287: /* tridxby ::= NOT INDEXED */
       case 283: /* tridxby ::= NOT INDEXED */
 {
   sqlite3ErrorMsg(pParse,
         "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
         "within triggers");
 }
         break;
       case 288: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
 { yygotominor.yy327 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy442, yymsp[0].minor.yy122, yymsp[-5].minor.yy258); }
         break;
       case 289: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt valuelist */
 {yygotominor.yy327 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy180, yymsp[0].minor.yy487.pList, yymsp[0].minor.yy487.pSelect, yymsp[-4].minor.yy258);}
       case 284: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
 { yygotominor.yy473 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy14, yymsp[0].minor.yy132, yymsp[-5].minor.yy186); }
         break;
       case 290: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select */
 {yygotominor.yy327 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy180, 0, yymsp[0].minor.yy159, yymsp[-4].minor.yy258);}
       case 285: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select */
 {yygotominor.yy473 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy408, yymsp[0].minor.yy3, yymsp[-4].minor.yy186);}
         break;
       case 291: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
 {yygotominor.yy327 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy122);}
       case 286: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
 {yygotominor.yy473 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy132);}
         break;
       case 292: /* trigger_cmd ::= select */
 {yygotominor.yy327 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy159); }
       case 287: /* trigger_cmd ::= select */
 {yygotominor.yy473 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy3); }
         break;
       case 293: /* expr ::= RAISE LP IGNORE RP */
       case 288: /* expr ::= RAISE LP IGNORE RP */
 {
   yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
   if( yygotominor.yy342.pExpr ){
     yygotominor.yy342.pExpr->affinity = OE_Ignore;
   yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
   if( yygotominor.yy346.pExpr ){
     yygotominor.yy346.pExpr->affinity = OE_Ignore;
   }
   yygotominor.yy342.zStart = yymsp[-3].minor.yy0.z;
   yygotominor.yy342.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
   yygotominor.yy346.zStart = yymsp[-3].minor.yy0.z;
   yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
 }
         break;
       case 294: /* expr ::= RAISE LP raisetype COMMA nm RP */
       case 289: /* expr ::= RAISE LP raisetype COMMA nm RP */
 {
   yygotominor.yy342.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
   if( yygotominor.yy342.pExpr ) {
     yygotominor.yy342.pExpr->affinity = (char)yymsp[-3].minor.yy392;
   yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
   if( yygotominor.yy346.pExpr ) {
     yygotominor.yy346.pExpr->affinity = (char)yymsp[-3].minor.yy328;
   }
   yygotominor.yy342.zStart = yymsp[-5].minor.yy0.z;
   yygotominor.yy342.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
   yygotominor.yy346.zStart = yymsp[-5].minor.yy0.z;
   yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
 }
         break;
       case 295: /* raisetype ::= ROLLBACK */
 {yygotominor.yy392 = OE_Rollback;}
       case 290: /* raisetype ::= ROLLBACK */
 {yygotominor.yy328 = OE_Rollback;}
         break;
       case 297: /* raisetype ::= FAIL */
 {yygotominor.yy392 = OE_Fail;}
       case 292: /* raisetype ::= FAIL */
 {yygotominor.yy328 = OE_Fail;}
         break;
       case 298: /* cmd ::= DROP TRIGGER ifexists fullname */
       case 293: /* cmd ::= DROP TRIGGER ifexists fullname */
 {
   sqlite3DropTrigger(pParse,yymsp[0].minor.yy347,yymsp[-1].minor.yy392);
   sqlite3DropTrigger(pParse,yymsp[0].minor.yy65,yymsp[-1].minor.yy328);
 }
         break;
       case 299: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
       case 294: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
 {
   sqlite3Attach(pParse, yymsp[-3].minor.yy342.pExpr, yymsp[-1].minor.yy342.pExpr, yymsp[0].minor.yy122);
   sqlite3Attach(pParse, yymsp[-3].minor.yy346.pExpr, yymsp[-1].minor.yy346.pExpr, yymsp[0].minor.yy132);
 }
         break;
       case 300: /* cmd ::= DETACH database_kw_opt expr */
       case 295: /* cmd ::= DETACH database_kw_opt expr */
 {
   sqlite3Detach(pParse, yymsp[0].minor.yy342.pExpr);
   sqlite3Detach(pParse, yymsp[0].minor.yy346.pExpr);
 }
         break;
       case 305: /* cmd ::= REINDEX */
       case 300: /* cmd ::= REINDEX */
 {sqlite3Reindex(pParse, 0, 0);}
         break;
       case 306: /* cmd ::= REINDEX nm dbnm */
       case 301: /* cmd ::= REINDEX nm dbnm */
 {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
         break;
       case 307: /* cmd ::= ANALYZE */
       case 302: /* cmd ::= ANALYZE */
 {sqlite3Analyze(pParse, 0, 0);}
         break;
       case 308: /* cmd ::= ANALYZE nm dbnm */
       case 303: /* cmd ::= ANALYZE nm dbnm */
 {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
         break;
       case 309: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
       case 304: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
 {
   sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy347,&yymsp[0].minor.yy0);
   sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy65,&yymsp[0].minor.yy0);
 }
         break;
       case 310: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
       case 305: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
 {
   sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0);
 }
         break;
       case 311: /* add_column_fullname ::= fullname */
       case 306: /* add_column_fullname ::= fullname */
 {
   pParse->db->lookaside.bEnabled = 0;
   sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy347);
   sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy65);
 }
         break;
       case 314: /* cmd ::= create_vtab */
       case 309: /* cmd ::= create_vtab */
 {sqlite3VtabFinishParse(pParse,0);}
         break;
       case 315: /* cmd ::= create_vtab LP vtabarglist RP */
       case 310: /* cmd ::= create_vtab LP vtabarglist RP */
 {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
         break;
       case 316: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
       case 311: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
 {
     sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy392);
     sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy328);
 }
         break;
       case 319: /* vtabarg ::= */
       case 314: /* vtabarg ::= */
 {sqlite3VtabArgInit(pParse);}
         break;
       case 321: /* vtabargtoken ::= ANY */
       case 322: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==322);
       case 323: /* lp ::= LP */ yytestcase(yyruleno==323);
       case 316: /* vtabargtoken ::= ANY */
       case 317: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==317);
       case 318: /* lp ::= LP */ yytestcase(yyruleno==318);
 {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
         break;
       case 322: /* with ::= */
 {yygotominor.yy59 = 0;}
         break;
       case 323: /* with ::= WITH wqlist */
       case 324: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==324);
 { yygotominor.yy59 = yymsp[0].minor.yy59; }
         break;
       case 325: /* wqlist ::= nm idxlist_opt AS LP select RP */
 {
   yygotominor.yy59 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy3);
 }
         break;
       case 326: /* wqlist ::= wqlist COMMA nm idxlist_opt AS LP select RP */
 {
   yygotominor.yy59 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy59, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy3);
 }
         break;
       default:
       /* (0) input ::= cmdlist */ yytestcase(yyruleno==0);
       /* (1) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==1);

@@ -116003,30 +118583,30 @@ static void yy_reduce(

       /* (20) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==20);
       /* (21) savepoint_opt ::= */ yytestcase(yyruleno==21);
       /* (25) cmd ::= create_table create_table_args */ yytestcase(yyruleno==25);
       /* (34) columnlist ::= columnlist COMMA column */ yytestcase(yyruleno==34);
       /* (35) columnlist ::= column */ yytestcase(yyruleno==35);
       /* (44) type ::= */ yytestcase(yyruleno==44);
       /* (51) signed ::= plus_num */ yytestcase(yyruleno==51);
       /* (52) signed ::= minus_num */ yytestcase(yyruleno==52);
       /* (53) carglist ::= carglist ccons */ yytestcase(yyruleno==53);
       /* (54) carglist ::= */ yytestcase(yyruleno==54);
       /* (61) ccons ::= NULL onconf */ yytestcase(yyruleno==61);
       /* (89) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==89);
       /* (90) conslist ::= tcons */ yytestcase(yyruleno==90);
       /* (92) tconscomma ::= */ yytestcase(yyruleno==92);
       /* (277) foreach_clause ::= */ yytestcase(yyruleno==277);
       /* (278) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==278);
       /* (285) tridxby ::= */ yytestcase(yyruleno==285);
       /* (303) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==303);
       /* (304) database_kw_opt ::= */ yytestcase(yyruleno==304);
       /* (312) kwcolumn_opt ::= */ yytestcase(yyruleno==312);
       /* (313) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==313);
       /* (317) vtabarglist ::= vtabarg */ yytestcase(yyruleno==317);
       /* (318) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==318);
       /* (320) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==320);
       /* (324) anylist ::= */ yytestcase(yyruleno==324);
       /* (325) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==325);
       /* (326) anylist ::= anylist ANY */ yytestcase(yyruleno==326);
       /* (36) columnlist ::= columnlist COMMA column */ yytestcase(yyruleno==36);
       /* (37) columnlist ::= column */ yytestcase(yyruleno==37);
       /* (43) type ::= */ yytestcase(yyruleno==43);
       /* (50) signed ::= plus_num */ yytestcase(yyruleno==50);
       /* (51) signed ::= minus_num */ yytestcase(yyruleno==51);
       /* (52) carglist ::= carglist ccons */ yytestcase(yyruleno==52);
       /* (53) carglist ::= */ yytestcase(yyruleno==53);
       /* (60) ccons ::= NULL onconf */ yytestcase(yyruleno==60);
       /* (88) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==88);
       /* (89) conslist ::= tcons */ yytestcase(yyruleno==89);
       /* (91) tconscomma ::= */ yytestcase(yyruleno==91);
       /* (273) foreach_clause ::= */ yytestcase(yyruleno==273);
       /* (274) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==274);
       /* (281) tridxby ::= */ yytestcase(yyruleno==281);
       /* (298) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==298);
       /* (299) database_kw_opt ::= */ yytestcase(yyruleno==299);
       /* (307) kwcolumn_opt ::= */ yytestcase(yyruleno==307);
       /* (308) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==308);
       /* (312) vtabarglist ::= vtabarg */ yytestcase(yyruleno==312);
       /* (313) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==313);
       /* (315) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==315);
       /* (319) anylist ::= */ yytestcase(yyruleno==319);
       /* (320) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==320);
       /* (321) anylist ::= anylist ANY */ yytestcase(yyruleno==321);
         break;
   };
   assert( yyruleno>=0 && yyruleno<sizeof(yyRuleInfo)/sizeof(yyRuleInfo[0]) );

@@ -116365,20 +118945,20 @@ const unsigned char ebcdicToAscii[] = {

 ** is substantially reduced.  This is important for embedded applications
 ** on platforms with limited memory.
 */
 /* Hash score: 175 */
 /* Hash score: 182 */
 static int keywordCode(const char *z, int n){
   /* zText[] encodes 811 bytes of keywords in 541 bytes */
   /* zText[] encodes 834 bytes of keywords in 554 bytes */
   /*   REINDEXEDESCAPEACHECKEYBEFOREIGNOREGEXPLAINSTEADDATABASELECT       */
   /*   ABLEFTHENDEFERRABLELSEXCEPTRANSACTIONATURALTERAISEXCLUSIVE         */
   /*   XISTSAVEPOINTERSECTRIGGEREFERENCESCONSTRAINTOFFSETEMPORARY         */
   /*   UNIQUERYATTACHAVINGROUPDATEBEGINNERELEASEBETWEENOTNULLIKE          */
   /*   CASCADELETECASECOLLATECREATECURRENT_DATEDETACHIMMEDIATEJOIN        */
   /*   SERTMATCHPLANALYZEPRAGMABORTVALUESVIRTUALIMITWHENWHERENAME         */
   /*   AFTEREPLACEANDEFAULTAUTOINCREMENTCASTCOLUMNCOMMITCONFLICTCROSS     */
   /*   CURRENT_TIMESTAMPRIMARYDEFERREDISTINCTDROPFAILFROMFULLGLOBYIF      */
   /*   ISNULLORDERESTRICTOUTERIGHTROLLBACKROWUNIONUSINGVACUUMVIEW         */
   /*   INITIALLY                                                          */
   static const char zText[540] = {
   /*   UNIQUERYWITHOUTERELEASEATTACHAVINGROUPDATEBEGINNERECURSIVE         */
   /*   BETWEENOTNULLIKECASCADELETECASECOLLATECREATECURRENT_DATEDETACH     */
   /*   IMMEDIATEJOINSERTMATCHPLANALYZEPRAGMABORTVALUESVIRTUALIMITWHEN     */
   /*   WHERENAMEAFTEREPLACEANDEFAULTAUTOINCREMENTCASTCOLUMNCOMMIT         */
   /*   CONFLICTCROSSCURRENT_TIMESTAMPRIMARYDEFERREDISTINCTDROPFAIL        */
   /*   FROMFULLGLOBYIFISNULLORDERESTRICTRIGHTROLLBACKROWUNIONUSING        */
   /*   VACUUMVIEWINITIALLY                                                */
   static const char zText[553] = {
     'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H',
     'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G',
     'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A',

@@ -116389,76 +118969,77 @@ static int keywordCode(const char *z, int n){

     'P','O','I','N','T','E','R','S','E','C','T','R','I','G','G','E','R','E',
     'F','E','R','E','N','C','E','S','C','O','N','S','T','R','A','I','N','T',
     'O','F','F','S','E','T','E','M','P','O','R','A','R','Y','U','N','I','Q',
     'U','E','R','Y','A','T','T','A','C','H','A','V','I','N','G','R','O','U',
     'P','D','A','T','E','B','E','G','I','N','N','E','R','E','L','E','A','S',
     'E','B','E','T','W','E','E','N','O','T','N','U','L','L','I','K','E','C',
     'A','S','C','A','D','E','L','E','T','E','C','A','S','E','C','O','L','L',
     'A','T','E','C','R','E','A','T','E','C','U','R','R','E','N','T','_','D',
     'A','T','E','D','E','T','A','C','H','I','M','M','E','D','I','A','T','E',
     'J','O','I','N','S','E','R','T','M','A','T','C','H','P','L','A','N','A',
     'L','Y','Z','E','P','R','A','G','M','A','B','O','R','T','V','A','L','U',
     'E','S','V','I','R','T','U','A','L','I','M','I','T','W','H','E','N','W',
     'H','E','R','E','N','A','M','E','A','F','T','E','R','E','P','L','A','C',
     'E','A','N','D','E','F','A','U','L','T','A','U','T','O','I','N','C','R',
     'E','M','E','N','T','C','A','S','T','C','O','L','U','M','N','C','O','M',
     'M','I','T','C','O','N','F','L','I','C','T','C','R','O','S','S','C','U',
     'R','R','E','N','T','_','T','I','M','E','S','T','A','M','P','R','I','M',
     'A','R','Y','D','E','F','E','R','R','E','D','I','S','T','I','N','C','T',
     'D','R','O','P','F','A','I','L','F','R','O','M','F','U','L','L','G','L',
     'O','B','Y','I','F','I','S','N','U','L','L','O','R','D','E','R','E','S',
     'T','R','I','C','T','O','U','T','E','R','I','G','H','T','R','O','L','L',
     'B','A','C','K','R','O','W','U','N','I','O','N','U','S','I','N','G','V',
     'A','C','U','U','M','V','I','E','W','I','N','I','T','I','A','L','L','Y',
     'U','E','R','Y','W','I','T','H','O','U','T','E','R','E','L','E','A','S',
     'E','A','T','T','A','C','H','A','V','I','N','G','R','O','U','P','D','A',
     'T','E','B','E','G','I','N','N','E','R','E','C','U','R','S','I','V','E',
     'B','E','T','W','E','E','N','O','T','N','U','L','L','I','K','E','C','A',
     'S','C','A','D','E','L','E','T','E','C','A','S','E','C','O','L','L','A',
     'T','E','C','R','E','A','T','E','C','U','R','R','E','N','T','_','D','A',
     'T','E','D','E','T','A','C','H','I','M','M','E','D','I','A','T','E','J',
     'O','I','N','S','E','R','T','M','A','T','C','H','P','L','A','N','A','L',
     'Y','Z','E','P','R','A','G','M','A','B','O','R','T','V','A','L','U','E',
     'S','V','I','R','T','U','A','L','I','M','I','T','W','H','E','N','W','H',
     'E','R','E','N','A','M','E','A','F','T','E','R','E','P','L','A','C','E',
     'A','N','D','E','F','A','U','L','T','A','U','T','O','I','N','C','R','E',
     'M','E','N','T','C','A','S','T','C','O','L','U','M','N','C','O','M','M',
     'I','T','C','O','N','F','L','I','C','T','C','R','O','S','S','C','U','R',
     'R','E','N','T','_','T','I','M','E','S','T','A','M','P','R','I','M','A',
     'R','Y','D','E','F','E','R','R','E','D','I','S','T','I','N','C','T','D',
     'R','O','P','F','A','I','L','F','R','O','M','F','U','L','L','G','L','O',
     'B','Y','I','F','I','S','N','U','L','L','O','R','D','E','R','E','S','T',
     'R','I','C','T','R','I','G','H','T','R','O','L','L','B','A','C','K','R',
     'O','W','U','N','I','O','N','U','S','I','N','G','V','A','C','U','U','M',
     'V','I','E','W','I','N','I','T','I','A','L','L','Y',
   };
   static const unsigned char aHash[127] = {
 , 101, 114,  70,   0,  45,   0,   0,  78,   0,  73,   0,   0,
 ,  12,  74,  15,   0, 113,  81,  50, 108,   0,  19,   0,   0,
 ,   0, 116, 111,   0,  22,  89,   0,   9,   0,   0,  66,  67,
 ,  65,   6,   0,  48,  86,  98,   0, 115,  97,   0,   0,  44,
 ,  99,  24,   0,  17,   0, 119,  49,  23,   0,   5, 106,  25,
 ,   0,   0, 121, 102,  56, 120,  53,  28,  51,   0,  87,   0,
 ,  26,   0,  95,   0,   0,   0,  91,  88,  93,  84, 105,  14,
 , 104,   0,  77,   0,  18,  85, 107,  32,   0, 117,  76, 109,
 ,  46,  80,   0,   0,  90,  40,   0, 112,   0,  36,   0,   0,
 ,   0,  82,  59,  60,   0,  20,  57,   0,  52,
 , 105, 117,  74,   0,  45,   0,   0,  82,   0,  77,   0,   0,
 ,  12,  78,  15,   0, 116,  85,  54, 112,   0,  19,   0,   0,
 ,   0, 119, 115,   0,  22,  93,   0,   9,   0,   0,  70,  71,
 ,  69,   6,   0,  48,  90, 102,   0, 118, 101,   0,   0,  44,
 , 103,  24,   0,  17,   0, 122,  53,  23,   0,   5, 110,  25,
 ,   0,   0, 124, 106,  60, 123,  57,  28,  55,   0,  91,   0,
 ,  26,   0,  99,   0,   0,   0,  95,  92,  97,  88, 109,  14,
 , 108,   0,  81,   0,  18,  89, 111,  32,   0, 120,  80, 113,
 ,  46,  84,   0,   0,  94,  40,  59, 114,   0,  36,   0,   0,
 ,   0,  86,  63,  64,   0,  20,  61,   0,  56,
   };
   static const unsigned char aNext[121] = {
   static const unsigned char aNext[124] = {
 ,   0,   0,   0,   4,   0,   0,   0,   0,   0,   0,   0,   0,
 ,   2,   0,   0,   0,   0,   0,   0,  13,   0,   0,   0,   0,
 ,   7,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 ,   0,   0,   0,  33,   0,  21,   0,   0,   0,  43,   3,  47,
 ,   0,   0,   0,  30,   0,  54,   0,  38,   0,   0,   0,   1,
 ,   0,   0,  63,   0,  41,   0,   0,   0,   0,   0,   0,   0,
 ,   0,   0,   0,   0,  31,  55,  16,  34,  10,   0,   0,   0,
 ,   0,   0,   0,  11,  68,  75,   0,   8,   0, 100,  94,   0,
 ,   0,  83,   0,  71,   0,   0, 110,  27,  37,  69,  79,   0,
 ,  64,   0,   0,
 ,   0,   0,   0,  33,   0,  21,   0,   0,   0,   0,   0,  50,
 ,  43,   3,  47,   0,   0,   0,   0,  30,   0,  58,   0,  38,
 ,   0,   0,   1,  66,   0,   0,  67,   0,  41,   0,   0,   0,
 ,   0,   0,  49,  65,   0,   0,   0,   0,  31,  52,  16,  34,
 ,   0,   0,   0,   0,   0,   0,   0,  11,  72,  79,   0,   8,
 , 104,  98,   0, 107,   0,  87,   0,  75,  51,   0,  27,  37,
 ,  83,   0,  35,  68,   0,   0,
   };
   static const unsigned char aLen[121] = {
   static const unsigned char aLen[124] = {
 ,   7,   5,   4,   6,   4,   5,   3,   6,   7,   3,   6,   6,
 ,   7,   3,   8,   2,   6,   5,   4,   4,   3,  10,   4,   6,
 ,   6,   2,   7,   5,   5,   9,   6,   9,   9,   7,  10,  10,
 ,   6,   2,   3,   9,   4,   2,   6,   5,   6,   6,   5,   6,
 ,   5,   7,   7,   7,   3,   2,   4,   4,   7,   3,   6,   4,
 ,   6,  12,   6,   9,   4,   6,   5,   4,   7,   6,   5,   6,
 ,   5,   4,   5,   6,   5,   7,   3,   7,  13,   2,   2,   4,
 ,   6,   8,   5,  17,  12,   7,   8,   8,   2,   4,   4,   4,
 ,   4,   2,   2,   6,   5,   8,   5,   5,   8,   3,   5,   5,
 ,   4,   9,   3,
 ,   6,   2,   3,   9,   4,   2,   6,   5,   7,   4,   5,   7,
 ,   6,   5,   6,   5,   5,   9,   7,   7,   3,   2,   4,   4,
 ,   3,   6,   4,   7,   6,  12,   6,   9,   4,   6,   5,   4,
 ,   6,   5,   6,   7,   5,   4,   5,   6,   5,   7,   3,   7,
 ,   2,   2,   4,   6,   6,   8,   5,  17,  12,   7,   8,   8,
 ,   4,   4,   4,   4,   4,   2,   2,   6,   5,   8,   5,   8,
 ,   5,   5,   6,   4,   9,   3,
   };
   static const unsigned short int aOffset[121] = {
   static const unsigned short int aOffset[124] = {
 ,   2,   2,   8,   9,  14,  16,  20,  23,  25,  25,  29,  33,
 ,  41,  46,  48,  53,  54,  59,  62,  65,  67,  69,  78,  81,
 ,  91,  95,  96, 101, 105, 109, 117, 122, 128, 136, 142, 152,
 , 162, 162, 165, 167, 167, 171, 176, 179, 184, 189, 194, 197,
 , 206, 210, 217, 223, 223, 223, 226, 229, 233, 234, 238, 244,
 , 255, 261, 273, 279, 288, 290, 296, 301, 303, 310, 315, 320,
 , 332, 337, 341, 344, 350, 354, 361, 363, 370, 372, 374, 383,
 , 393, 399, 407, 412, 412, 428, 435, 442, 443, 450, 454, 458,
 , 466, 469, 471, 473, 479, 483, 491, 495, 500, 508, 511, 516,
 , 527, 531, 536,
 , 162, 162, 165, 167, 167, 171, 176, 179, 184, 184, 188, 192,
 , 204, 209, 212, 218, 221, 225, 234, 240, 240, 240, 243, 246,
 , 251, 255, 261, 265, 272, 278, 290, 296, 305, 307, 313, 318,
 , 327, 332, 337, 343, 349, 354, 358, 361, 367, 371, 378, 380,
 , 389, 391, 400, 404, 410, 416, 424, 429, 429, 445, 452, 459,
 , 467, 471, 475, 479, 483, 486, 488, 490, 496, 500, 508, 513,
 , 524, 529, 534, 540, 544, 549,
   };
   static const unsigned char aCode[121] = {
   static const unsigned char aCode[124] = {
     TK_REINDEX,    TK_INDEXED,    TK_INDEX,      TK_DESC,       TK_ESCAPE,
     TK_EACH,       TK_CHECK,      TK_KEY,        TK_BEFORE,     TK_FOREIGN,
     TK_FOR,        TK_IGNORE,     TK_LIKE_KW,    TK_EXPLAIN,    TK_INSTEAD,

@@ -116468,22 +119049,22 @@ static int keywordCode(const char *z, int n){

     TK_ALTER,      TK_RAISE,      TK_EXCLUSIVE,  TK_EXISTS,     TK_SAVEPOINT,
     TK_INTERSECT,  TK_TRIGGER,    TK_REFERENCES, TK_CONSTRAINT, TK_INTO,
     TK_OFFSET,     TK_OF,         TK_SET,        TK_TEMP,       TK_TEMP,
     TK_OR,         TK_UNIQUE,     TK_QUERY,      TK_ATTACH,     TK_HAVING,
     TK_GROUP,      TK_UPDATE,     TK_BEGIN,      TK_JOIN_KW,    TK_RELEASE,
     TK_BETWEEN,    TK_NOTNULL,    TK_NOT,        TK_NO,         TK_NULL,
     TK_LIKE_KW,    TK_CASCADE,    TK_ASC,        TK_DELETE,     TK_CASE,
     TK_COLLATE,    TK_CREATE,     TK_CTIME_KW,   TK_DETACH,     TK_IMMEDIATE,
     TK_JOIN,       TK_INSERT,     TK_MATCH,      TK_PLAN,       TK_ANALYZE,
     TK_PRAGMA,     TK_ABORT,      TK_VALUES,     TK_VIRTUAL,    TK_LIMIT,
     TK_WHEN,       TK_WHERE,      TK_RENAME,     TK_AFTER,      TK_REPLACE,
     TK_AND,        TK_DEFAULT,    TK_AUTOINCR,   TK_TO,         TK_IN,
     TK_CAST,       TK_COLUMNKW,   TK_COMMIT,     TK_CONFLICT,   TK_JOIN_KW,
     TK_CTIME_KW,   TK_CTIME_KW,   TK_PRIMARY,    TK_DEFERRED,   TK_DISTINCT,
     TK_IS,         TK_DROP,       TK_FAIL,       TK_FROM,       TK_JOIN_KW,
     TK_LIKE_KW,    TK_BY,         TK_IF,         TK_ISNULL,     TK_ORDER,
     TK_RESTRICT,   TK_JOIN_KW,    TK_JOIN_KW,    TK_ROLLBACK,   TK_ROW,
     TK_UNION,      TK_USING,      TK_VACUUM,     TK_VIEW,       TK_INITIALLY,
     TK_ALL,
     TK_OR,         TK_UNIQUE,     TK_QUERY,      TK_WITHOUT,    TK_WITH,
     TK_JOIN_KW,    TK_RELEASE,    TK_ATTACH,     TK_HAVING,     TK_GROUP,
     TK_UPDATE,     TK_BEGIN,      TK_JOIN_KW,    TK_RECURSIVE,  TK_BETWEEN,
     TK_NOTNULL,    TK_NOT,        TK_NO,         TK_NULL,       TK_LIKE_KW,
     TK_CASCADE,    TK_ASC,        TK_DELETE,     TK_CASE,       TK_COLLATE,
     TK_CREATE,     TK_CTIME_KW,   TK_DETACH,     TK_IMMEDIATE,  TK_JOIN,
     TK_INSERT,     TK_MATCH,      TK_PLAN,       TK_ANALYZE,    TK_PRAGMA,
     TK_ABORT,      TK_VALUES,     TK_VIRTUAL,    TK_LIMIT,      TK_WHEN,
     TK_WHERE,      TK_RENAME,     TK_AFTER,      TK_REPLACE,    TK_AND,
     TK_DEFAULT,    TK_AUTOINCR,   TK_TO,         TK_IN,         TK_CAST,
     TK_COLUMNKW,   TK_COMMIT,     TK_CONFLICT,   TK_JOIN_KW,    TK_CTIME_KW,
     TK_CTIME_KW,   TK_PRIMARY,    TK_DEFERRED,   TK_DISTINCT,   TK_IS,
     TK_DROP,       TK_FAIL,       TK_FROM,       TK_JOIN_KW,    TK_LIKE_KW,
     TK_BY,         TK_IF,         TK_ISNULL,     TK_ORDER,      TK_RESTRICT,
     TK_JOIN_KW,    TK_ROLLBACK,   TK_ROW,        TK_UNION,      TK_USING,
     TK_VACUUM,     TK_VIEW,       TK_INITIALLY,  TK_ALL,
   };
   int h, i;
   if( n<2 ) return TK_ID;

@@ -116540,79 +119121,82 @@ static int keywordCode(const char *z, int n){

       testcase( i==45 ); /* OR */
       testcase( i==46 ); /* UNIQUE */
       testcase( i==47 ); /* QUERY */
       testcase( i==48 ); /* ATTACH */
       testcase( i==49 ); /* HAVING */
       testcase( i==50 ); /* GROUP */
       testcase( i==51 ); /* UPDATE */
       testcase( i==52 ); /* BEGIN */
       testcase( i==53 ); /* INNER */
       testcase( i==54 ); /* RELEASE */
       testcase( i==55 ); /* BETWEEN */
       testcase( i==56 ); /* NOTNULL */
       testcase( i==57 ); /* NOT */
       testcase( i==58 ); /* NO */
       testcase( i==59 ); /* NULL */
       testcase( i==60 ); /* LIKE */
       testcase( i==61 ); /* CASCADE */
       testcase( i==62 ); /* ASC */
       testcase( i==63 ); /* DELETE */
       testcase( i==64 ); /* CASE */
       testcase( i==65 ); /* COLLATE */
       testcase( i==66 ); /* CREATE */
       testcase( i==67 ); /* CURRENT_DATE */
       testcase( i==68 ); /* DETACH */
       testcase( i==69 ); /* IMMEDIATE */
       testcase( i==70 ); /* JOIN */
       testcase( i==71 ); /* INSERT */
       testcase( i==72 ); /* MATCH */
       testcase( i==73 ); /* PLAN */
       testcase( i==74 ); /* ANALYZE */
       testcase( i==75 ); /* PRAGMA */
       testcase( i==76 ); /* ABORT */
       testcase( i==77 ); /* VALUES */
       testcase( i==78 ); /* VIRTUAL */
       testcase( i==79 ); /* LIMIT */
       testcase( i==80 ); /* WHEN */
       testcase( i==81 ); /* WHERE */
       testcase( i==82 ); /* RENAME */
       testcase( i==83 ); /* AFTER */
       testcase( i==84 ); /* REPLACE */
       testcase( i==85 ); /* AND */
       testcase( i==86 ); /* DEFAULT */
       testcase( i==87 ); /* AUTOINCREMENT */
       testcase( i==88 ); /* TO */
       testcase( i==89 ); /* IN */
       testcase( i==90 ); /* CAST */
       testcase( i==91 ); /* COLUMN */
       testcase( i==92 ); /* COMMIT */
       testcase( i==93 ); /* CONFLICT */
       testcase( i==94 ); /* CROSS */
       testcase( i==95 ); /* CURRENT_TIMESTAMP */
       testcase( i==96 ); /* CURRENT_TIME */
       testcase( i==97 ); /* PRIMARY */
       testcase( i==98 ); /* DEFERRED */
       testcase( i==99 ); /* DISTINCT */
       testcase( i==100 ); /* IS */
       testcase( i==101 ); /* DROP */
       testcase( i==102 ); /* FAIL */
       testcase( i==103 ); /* FROM */
       testcase( i==104 ); /* FULL */
       testcase( i==105 ); /* GLOB */
       testcase( i==106 ); /* BY */
       testcase( i==107 ); /* IF */
       testcase( i==108 ); /* ISNULL */
       testcase( i==109 ); /* ORDER */
       testcase( i==110 ); /* RESTRICT */
       testcase( i==111 ); /* OUTER */
       testcase( i==112 ); /* RIGHT */
       testcase( i==113 ); /* ROLLBACK */
       testcase( i==114 ); /* ROW */
       testcase( i==115 ); /* UNION */
       testcase( i==116 ); /* USING */
       testcase( i==117 ); /* VACUUM */
       testcase( i==118 ); /* VIEW */
       testcase( i==119 ); /* INITIALLY */
       testcase( i==120 ); /* ALL */
       testcase( i==48 ); /* WITHOUT */
       testcase( i==49 ); /* WITH */
       testcase( i==50 ); /* OUTER */
       testcase( i==51 ); /* RELEASE */
       testcase( i==52 ); /* ATTACH */
       testcase( i==53 ); /* HAVING */
       testcase( i==54 ); /* GROUP */
       testcase( i==55 ); /* UPDATE */
       testcase( i==56 ); /* BEGIN */
       testcase( i==57 ); /* INNER */
       testcase( i==58 ); /* RECURSIVE */
       testcase( i==59 ); /* BETWEEN */
       testcase( i==60 ); /* NOTNULL */
       testcase( i==61 ); /* NOT */
       testcase( i==62 ); /* NO */
       testcase( i==63 ); /* NULL */
       testcase( i==64 ); /* LIKE */
       testcase( i==65 ); /* CASCADE */
       testcase( i==66 ); /* ASC */
       testcase( i==67 ); /* DELETE */
       testcase( i==68 ); /* CASE */
       testcase( i==69 ); /* COLLATE */
       testcase( i==70 ); /* CREATE */
       testcase( i==71 ); /* CURRENT_DATE */
       testcase( i==72 ); /* DETACH */
       testcase( i==73 ); /* IMMEDIATE */
       testcase( i==74 ); /* JOIN */
       testcase( i==75 ); /* INSERT */
       testcase( i==76 ); /* MATCH */
       testcase( i==77 ); /* PLAN */
       testcase( i==78 ); /* ANALYZE */
       testcase( i==79 ); /* PRAGMA */
       testcase( i==80 ); /* ABORT */
       testcase( i==81 ); /* VALUES */
       testcase( i==82 ); /* VIRTUAL */
       testcase( i==83 ); /* LIMIT */
       testcase( i==84 ); /* WHEN */
       testcase( i==85 ); /* WHERE */
       testcase( i==86 ); /* RENAME */
       testcase( i==87 ); /* AFTER */
       testcase( i==88 ); /* REPLACE */
       testcase( i==89 ); /* AND */
       testcase( i==90 ); /* DEFAULT */
       testcase( i==91 ); /* AUTOINCREMENT */
       testcase( i==92 ); /* TO */
       testcase( i==93 ); /* IN */
       testcase( i==94 ); /* CAST */
       testcase( i==95 ); /* COLUMN */
       testcase( i==96 ); /* COMMIT */
       testcase( i==97 ); /* CONFLICT */
       testcase( i==98 ); /* CROSS */
       testcase( i==99 ); /* CURRENT_TIMESTAMP */
       testcase( i==100 ); /* CURRENT_TIME */
       testcase( i==101 ); /* PRIMARY */
       testcase( i==102 ); /* DEFERRED */
       testcase( i==103 ); /* DISTINCT */
       testcase( i==104 ); /* IS */
       testcase( i==105 ); /* DROP */
       testcase( i==106 ); /* FAIL */
       testcase( i==107 ); /* FROM */
       testcase( i==108 ); /* FULL */
       testcase( i==109 ); /* GLOB */
       testcase( i==110 ); /* BY */
       testcase( i==111 ); /* IF */
       testcase( i==112 ); /* ISNULL */
       testcase( i==113 ); /* ORDER */
       testcase( i==114 ); /* RESTRICT */
       testcase( i==115 ); /* RIGHT */
       testcase( i==116 ); /* ROLLBACK */
       testcase( i==117 ); /* ROW */
       testcase( i==118 ); /* UNION */
       testcase( i==119 ); /* USING */
       testcase( i==120 ); /* VACUUM */
       testcase( i==121 ); /* VIEW */
       testcase( i==122 ); /* INITIALLY */
       testcase( i==123 ); /* ALL */
       return aCode[i];
     }
   }

@@ -116621,7 +119205,7 @@ static int keywordCode(const char *z, int n){

 SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){
   return keywordCode((char*)z, n);
 }
 #define SQLITE_N_KEYWORD 121
 #define SQLITE_N_KEYWORD 124
 /************** End of keywordhash.h *****************************************/
 /************** Continuing where we left off in tokenize.c *******************/

@@ -116865,24 +119449,15 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){

       for(i=1; sqlite3Isdigit(z[i]); i++){}
       return i;
     }
     case '#': {
       for(i=1; sqlite3Isdigit(z[i]); i++){}
       if( i>1 ){
         /* Parameters of the form #NNN (where NNN is a number) are used
         ** internally by sqlite3NestedParse.  */
         *tokenType = TK_REGISTER;
         return i;
       }
       /* Fall through into the next case if the '#' is not followed by
       ** a digit. Try to match #AAAA where AAAA is a parameter name. */
     }
 #ifndef SQLITE_OMIT_TCL_VARIABLE
     case '$':
 #endif
     case '@':  /* For compatibility with MS SQL Server */
     case '#':
     case ':': {
       int n = 0;
       testcase( z[0]=='$' );  testcase( z[0]=='@' );  testcase( z[0]==':' );
       testcase( z[0]=='$' );  testcase( z[0]=='@' );
       testcase( z[0]==':' );  testcase( z[0]=='#' );
       *tokenType = TK_VARIABLE;
       for(i=1; (c=z[i])!=0; i++){
         if( IdChar(c) ){

@@ -117065,10 +119640,10 @@ abort_parse:

     sqlite3DeleteTable(db, pParse->pNewTable);
   }
   if( pParse->bFreeWith ) sqlite3WithDelete(db, pParse->pWith);
   sqlite3DeleteTrigger(db, pParse->pNewTrigger);
   for(i=pParse->nzVar-1; i>=0; i--) sqlite3DbFree(db, pParse->azVar[i]);
   sqlite3DbFree(db, pParse->azVar);
   sqlite3DbFree(db, pParse->aAlias);
   while( pParse->pAinc ){
     AutoincInfo *p = pParse->pAinc;
     pParse->pAinc = p->pNext;

@@ -117596,13 +120171,6 @@ SQLITE_API int sqlite3_initialize(void){

   */
   if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;
 #ifdef SQLITE_ENABLE_SQLLOG
   {
     extern void sqlite3_init_sqllog(void);
     sqlite3_init_sqllog();
   }
 #endif
   /* Make sure the mutex subsystem is initialized.  If unable to
   ** initialize the mutex subsystem, return early with the error.
   ** If the system is so sick that we are unable to allocate a mutex,

@@ -117976,6 +120544,13 @@ SQLITE_API int sqlite3_config(int op, ...){

       break;
     }
 #if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC)
     case SQLITE_CONFIG_WIN32_HEAPSIZE: {
       sqlite3GlobalConfig.nHeap = va_arg(ap, int);
       break;
     }
 #endif
     default: {
       rc = SQLITE_ERROR;
       break;

@@ -118042,7 +120617,8 @@ static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){

     db->lookaside.bEnabled = 1;
     db->lookaside.bMalloced = pBuf==0 ?1:0;
   }else{
     db->lookaside.pEnd = 0;
     db->lookaside.pStart = db;
     db->lookaside.pEnd = db;
     db->lookaside.bEnabled = 0;
     db->lookaside.bMalloced = 0;
   }

@@ -118440,9 +121016,7 @@ SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){

 #endif
   sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
   if( db->pErr ){
     sqlite3ValueFree(db->pErr);
   }
   sqlite3ValueFree(db->pErr);
   sqlite3CloseExtensions(db);
   db->magic = SQLITE_MAGIC_ERROR;

@@ -118517,8 +121091,7 @@ SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){

 ** Return a static string containing the name corresponding to the error code
 ** specified in the argument.
 */
 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) || \
     defined(SQLITE_DEBUG_OS_TRACE)
 #if defined(SQLITE_TEST)
 SQLITE_PRIVATE const char *sqlite3ErrName(int rc){
   const char *zName = 0;
   int i, origRc = rc;

@@ -118540,6 +121113,7 @@ SQLITE_PRIVATE const char *sqlite3ErrName(int rc){

       case SQLITE_READONLY_RECOVERY:  zName = "SQLITE_READONLY_RECOVERY"; break;
       case SQLITE_READONLY_CANTLOCK:  zName = "SQLITE_READONLY_CANTLOCK"; break;
       case SQLITE_READONLY_ROLLBACK:  zName = "SQLITE_READONLY_ROLLBACK"; break;
       case SQLITE_READONLY_DBMOVED:   zName = "SQLITE_READONLY_DBMOVED";  break;
       case SQLITE_INTERRUPT:          zName = "SQLITE_INTERRUPT";         break;
       case SQLITE_IOERR:              zName = "SQLITE_IOERR";             break;
       case SQLITE_IOERR_READ:         zName = "SQLITE_IOERR_READ";        break;

@@ -118596,6 +121170,7 @@ SQLITE_PRIVATE const char *sqlite3ErrName(int rc){

       case SQLITE_CONSTRAINT_VTAB:    zName = "SQLITE_CONSTRAINT_VTAB";   break;
       case SQLITE_CONSTRAINT_FUNCTION:
                                 zName = "SQLITE_CONSTRAINT_FUNCTION";     break;
       case SQLITE_CONSTRAINT_ROWID:   zName = "SQLITE_CONSTRAINT_ROWID";  break;
       case SQLITE_MISMATCH:           zName = "SQLITE_MISMATCH";          break;
       case SQLITE_MISUSE:             zName = "SQLITE_MISUSE";            break;
       case SQLITE_NOLFS:              zName = "SQLITE_NOLFS";             break;

@@ -118823,6 +121398,7 @@ SQLITE_PRIVATE int sqlite3CreateFunc(

 ){
   FuncDef *p;
   int nName;
   int extraFlags;
   assert( sqlite3_mutex_held(db->mutex) );
   if( zFunctionName==0 ||

@@ -118833,6 +121409,10 @@ SQLITE_PRIVATE int sqlite3CreateFunc(

       (255<(nName = sqlite3Strlen30( zFunctionName))) ){
     return SQLITE_MISUSE_BKPT;
   }
   assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
   extraFlags = enc &  SQLITE_DETERMINISTIC;
   enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY);
 #ifndef SQLITE_OMIT_UTF16
   /* If SQLITE_UTF16 is specified as the encoding type, transform this

@@ -118846,10 +121426,10 @@ SQLITE_PRIVATE int sqlite3CreateFunc(

     enc = SQLITE_UTF16NATIVE;
   }else if( enc==SQLITE_ANY ){
     int rc;
     rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
     rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8|extraFlags,
          pUserData, xFunc, xStep, xFinal, pDestructor);
     if( rc==SQLITE_OK ){
       rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
       rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE|extraFlags,
           pUserData, xFunc, xStep, xFinal, pDestructor);
     }
     if( rc!=SQLITE_OK ){

@@ -118892,7 +121472,8 @@ SQLITE_PRIVATE int sqlite3CreateFunc(

     pDestructor->nRef++;
   }
   p->pDestructor = pDestructor;
   p->funcFlags &= SQLITE_FUNC_ENCMASK;
   p->funcFlags = (p->funcFlags & SQLITE_FUNC_ENCMASK) | extraFlags;
   testcase( p->funcFlags & SQLITE_DETERMINISTIC );
   p->xFunc = xFunc;
   p->xStep = xStep;
   p->xFinalize = xFinal;

@@ -119322,6 +121903,7 @@ SQLITE_API const char *sqlite3_errmsg(sqlite3 *db){

   if( db->mallocFailed ){
     z = sqlite3ErrStr(SQLITE_NOMEM);
   }else{
     testcase( db->pErr==0 );
     z = (char*)sqlite3_value_text(db->pErr);
     assert( !db->mallocFailed );
     if( z==0 ){

@@ -119363,8 +121945,7 @@ SQLITE_API const void *sqlite3_errmsg16(sqlite3 *db){

   }else{
     z = sqlite3_value_text16(db->pErr);
     if( z==0 ){
       sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
            SQLITE_UTF8, SQLITE_STATIC);
       sqlite3Error(db, db->errCode, sqlite3ErrStr(db->errCode));
       z = sqlite3_value_text16(db->pErr);
     }
     /* A malloc() may have failed within the call to sqlite3_value_text16()

@@ -119412,6 +121993,32 @@ SQLITE_API const char *sqlite3_errstr(int rc){

 }
 /*
 ** Invalidate all cached KeyInfo objects for database connection "db"
 */
 static void invalidateCachedKeyInfo(sqlite3 *db){
   Db *pDb;                    /* A single database */
   int iDb;                    /* The database index number */
   HashElem *k;                /* For looping over tables in pDb */
   Table *pTab;                /* A table in the database */
   Index *pIdx;                /* Each index */
   for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
     if( pDb->pBt==0 ) continue;
     sqlite3BtreeEnter(pDb->pBt);
     for(k=sqliteHashFirst(&pDb->pSchema->tblHash);  k; k=sqliteHashNext(k)){
       pTab = (Table*)sqliteHashData(k);
       for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
         if( pIdx->pKeyInfo && pIdx->pKeyInfo->db==db ){
           sqlite3KeyInfoUnref(pIdx->pKeyInfo);
           pIdx->pKeyInfo = 0;
         }
       }
     }
     sqlite3BtreeLeave(pDb->pBt);
   }
 }
 /*
 ** Create a new collating function for database "db".  The name is zName
 ** and the encoding is enc.
 */

@@ -119455,6 +122062,7 @@ static int createCollation(

       return SQLITE_BUSY;
     }
     sqlite3ExpirePreparedStatements(db);
     invalidateCachedKeyInfo(db);
     /* If collation sequence pColl was created directly by a call to
     ** sqlite3_create_collation, and not generated by synthCollSeq(),

@@ -120051,8 +122659,6 @@ static int openDatabase(

   }
 #endif
   sqlite3Error(db, rc, 0);
   /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
   ** mode.  -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
   ** mode.  Doing nothing at all also makes NORMAL the default.

@@ -120063,6 +122669,8 @@ static int openDatabase(

                           SQLITE_DEFAULT_LOCKING_MODE);
 #endif
   if( rc ) sqlite3Error(db, rc, 0);
   /* Enable the lookaside-malloc subsystem */
   setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside,
                         sqlite3GlobalConfig.nLookaside);

@@ -120522,7 +123130,7 @@ SQLITE_API int sqlite3_test_control(int op, ...){

     ** to the xRandomness method of the default VFS.
     */
     case SQLITE_TESTCTRL_PRNG_RESET: {
       sqlite3PrngResetState();
       sqlite3_randomness(0,0);
       break;
     }

@@ -120722,6 +123330,34 @@ SQLITE_API int sqlite3_test_control(int op, ...){

     }
 #endif
     /*   sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int);
     **
     ** Set or clear a flag that indicates that the database file is always well-
     ** formed and never corrupt.  This flag is clear by default, indicating that
     ** database files might have arbitrary corruption.  Setting the flag during
     ** testing causes certain assert() statements in the code to be activated
     ** that demonstrat invariants on well-formed database files.
     */
     case SQLITE_TESTCTRL_NEVER_CORRUPT: {
       sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int);
       break;
     }
     /*   sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr);
     **
     ** Set the VDBE coverage callback function to xCallback with context
     ** pointer ptr.
     */
     case SQLITE_TESTCTRL_VDBE_COVERAGE: {
 #ifdef SQLITE_VDBE_COVERAGE
       typedef void (*branch_callback)(void*,int,u8,u8);
       sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback);
       sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*);
 #endif
       break;
     }
   }
   va_end(ap);
 #endif /* SQLITE_OMIT_BUILTIN_TEST */

@@ -122240,6 +124876,10 @@ struct Fts3MultiSegReader {

 SQLITE_PRIVATE int sqlite3Fts3Incrmerge(Fts3Table*,int,int);
 #define fts3GetVarint32(p, piVal) (                                           \
   (*(u8*)(p)&0x80) ? sqlite3Fts3GetVarint32(p, piVal) : (*piVal=*(u8*)(p), 1) \
 )
 /* fts3.c */
 SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *, sqlite3_int64);
 SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *, sqlite_int64 *);

@@ -122347,21 +124987,37 @@ SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){

   return (int) (q - (unsigned char *)p);
 }
 #define GETVARINT_STEP(v, ptr, shift, mask1, mask2, var, ret) \
   v = (v & mask1) | ( (*ptr++) << shift );                    \
   if( (v & mask2)==0 ){ var = v; return ret; }
 #define GETVARINT_INIT(v, ptr, shift, mask1, mask2, var, ret) \
   v = (*ptr++);                                               \
   if( (v & mask2)==0 ){ var = v; return ret; }
 /*
 ** Read a 64-bit variable-length integer from memory starting at p[0].
 ** Return the number of bytes read, or 0 on error.
 ** The value is stored in *v.
 */
 SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *p, sqlite_int64 *v){
   const unsigned char *q = (const unsigned char *) p;
   sqlite_uint64 x = 0, y = 1;
   while( (*q&0x80)==0x80 && q-(unsigned char *)p<FTS3_VARINT_MAX ){
     x += y * (*q++ & 0x7f);
     y <<= 7;
   }
   x += y * (*q++);
   *v = (sqlite_int64) x;
   return (int) (q - (unsigned char *)p);
   const char *pStart = p;
   u32 a;
   u64 b;
   int shift;
   GETVARINT_INIT(a, p, 0,  0x00,     0x80, *v, 1);
   GETVARINT_STEP(a, p, 7,  0x7F,     0x4000, *v, 2);
   GETVARINT_STEP(a, p, 14, 0x3FFF,   0x200000, *v, 3);
   GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *v, 4);
   b = (a & 0x0FFFFFFF );
   for(shift=28; shift<=63; shift+=7){
     u64 c = *p++;
     b += (c&0x7F) << shift;
     if( (c & 0x80)==0 ) break;
   }
   *v = b;
   return (int)(p - pStart);
 }
 /*

@@ -122369,10 +125025,21 @@ SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *p, sqlite_int64 *v){

 ** 32-bit integer before it is returned.
 */
 SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *p, int *pi){
  sqlite_int64 i;
  int ret = sqlite3Fts3GetVarint(p, &i);
  *pi = (int) i;
  return ret;
   u32 a;
 #ifndef fts3GetVarint32
   GETVARINT_INIT(a, p, 0,  0x00,     0x80, *pi, 1);
 #else
   a = (*p++);
   assert( a & 0x80 );
 #endif
   GETVARINT_STEP(a, p, 7,  0x7F,     0x4000, *pi, 2);
   GETVARINT_STEP(a, p, 14, 0x3FFF,   0x200000, *pi, 3);
   GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *pi, 4);
   a = (a & 0x0FFFFFFF );
   *pi = (int)(a | ((u32)(*p & 0x0F) << 28));
   return 5;
 }
 /*

@@ -123462,6 +126129,19 @@ static int fts3CreateMethod(

   return fts3InitVtab(1, db, pAux, argc, argv, ppVtab, pzErr);
 }
 /*
 ** Set the pIdxInfo->estimatedRows variable to nRow. Unless this
 ** extension is currently being used by a version of SQLite too old to
 ** support estimatedRows. In that case this function is a no-op.
 */
 static void fts3SetEstimatedRows(sqlite3_index_info *pIdxInfo, i64 nRow){
 #if SQLITE_VERSION_NUMBER>=3008002
   if( sqlite3_libversion_number()>=3008002 ){
     pIdxInfo->estimatedRows = nRow;
   }
 #endif
 }
 /*
 ** Implementation of the xBestIndex method for FTS3 tables. There
 ** are three possible strategies, in order of preference:

@@ -123489,7 +126169,20 @@ static int fts3BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){

   for(i=0; i<pInfo->nConstraint; i++){
     int bDocid;                 /* True if this constraint is on docid */
     struct sqlite3_index_constraint *pCons = &pInfo->aConstraint[i];
     if( pCons->usable==0 ) continue;
     if( pCons->usable==0 ){
       if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH ){
         /* There exists an unusable MATCH constraint. This means that if
         ** the planner does elect to use the results of this call as part
         ** of the overall query plan the user will see an "unable to use
         ** function MATCH in the requested context" error. To discourage
         ** this, return a very high cost here.  */
         pInfo->idxNum = FTS3_FULLSCAN_SEARCH;
         pInfo->estimatedCost = 1e50;
         fts3SetEstimatedRows(pInfo, ((sqlite3_int64)1) << 50);
         return SQLITE_OK;
       }
       continue;
     }
     bDocid = (pCons->iColumn<0 || pCons->iColumn==p->nColumn+1);

@@ -123732,10 +126425,10 @@ static int fts3ScanInteriorNode(

     /* Load the next term on the node into zBuffer. Use realloc() to expand
     ** the size of zBuffer if required.  */
     if( !isFirstTerm ){
       zCsr += sqlite3Fts3GetVarint32(zCsr, &nPrefix);
       zCsr += fts3GetVarint32(zCsr, &nPrefix);
     }
     isFirstTerm = 0;
     zCsr += sqlite3Fts3GetVarint32(zCsr, &nSuffix);
     zCsr += fts3GetVarint32(zCsr, &nSuffix);
     if( nPrefix<0 || nSuffix<0 || &zCsr[nSuffix]>zEnd ){
       rc = FTS_CORRUPT_VTAB;

@@ -123823,7 +126516,7 @@ static int fts3SelectLeaf(

   assert( piLeaf || piLeaf2 );
   sqlite3Fts3GetVarint32(zNode, &iHeight);
   fts3GetVarint32(zNode, &iHeight);
   rc = fts3ScanInteriorNode(zTerm, nTerm, zNode, nNode, piLeaf, piLeaf2);
   assert( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );

@@ -124025,11 +126718,11 @@ static void fts3PoslistMerge(

     int iCol1;         /* The current column index in pp1 */
     int iCol2;         /* The current column index in pp2 */
     if( *p1==POS_COLUMN ) sqlite3Fts3GetVarint32(&p1[1], &iCol1);
     if( *p1==POS_COLUMN ) fts3GetVarint32(&p1[1], &iCol1);
     else if( *p1==POS_END ) iCol1 = POSITION_LIST_END;
     else iCol1 = 0;
     if( *p2==POS_COLUMN ) sqlite3Fts3GetVarint32(&p2[1], &iCol2);
     if( *p2==POS_COLUMN ) fts3GetVarint32(&p2[1], &iCol2);
     else if( *p2==POS_END ) iCol2 = POSITION_LIST_END;
     else iCol2 = 0;

@@ -124122,11 +126815,11 @@ static int fts3PoslistPhraseMerge(

   assert( p!=0 && *p1!=0 && *p2!=0 );
   if( *p1==POS_COLUMN ){
     p1++;
     p1 += sqlite3Fts3GetVarint32(p1, &iCol1);
     p1 += fts3GetVarint32(p1, &iCol1);
   }
   if( *p2==POS_COLUMN ){
     p2++;
     p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
     p2 += fts3GetVarint32(p2, &iCol2);
   }
   while( 1 ){

@@ -124176,9 +126869,9 @@ static int fts3PoslistPhraseMerge(

       if( 0==*p1 || 0==*p2 ) break;
       p1++;
       p1 += sqlite3Fts3GetVarint32(p1, &iCol1);
       p1 += fts3GetVarint32(p1, &iCol1);
       p2++;
       p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
       p2 += fts3GetVarint32(p2, &iCol2);
     }
     /* Advance pointer p1 or p2 (whichever corresponds to the smaller of

@@ -124190,12 +126883,12 @@ static int fts3PoslistPhraseMerge(

       fts3ColumnlistCopy(0, &p1);
       if( 0==*p1 ) break;
       p1++;
       p1 += sqlite3Fts3GetVarint32(p1, &iCol1);
       p1 += fts3GetVarint32(p1, &iCol1);
     }else{
       fts3ColumnlistCopy(0, &p2);
       if( 0==*p2 ) break;
       p2++;
       p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
       p2 += fts3GetVarint32(p2, &iCol2);
     }
   }

@@ -127362,7 +130055,7 @@ static void fts3EvalUpdateCounts(Fts3Expr *pExpr){

         pExpr->aMI[iCol*3 + 2] += (iCnt>0);
         if( *p==0x00 ) break;
         p++;
         p += sqlite3Fts3GetVarint32(p, &iCol);
         p += fts3GetVarint32(p, &iCol);
       }
     }

@@ -127663,7 +130356,7 @@ SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(

   if( *pIter==0x01 ){
     pIter++;
     pIter += sqlite3Fts3GetVarint32(pIter, &iThis);
     pIter += fts3GetVarint32(pIter, &iThis);
   }else{
     iThis = 0;
   }

@@ -127671,7 +130364,7 @@ SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(

     fts3ColumnlistCopy(0, &pIter);
     if( *pIter==0x00 ) return 0;
     pIter++;
     pIter += sqlite3Fts3GetVarint32(pIter, &iThis);
     pIter += fts3GetVarint32(pIter, &iThis);
   }
   *ppOut = ((iCol==iThis)?pIter:0);

@@ -128437,6 +131130,11 @@ SQLITE_PRIVATE int sqlite3Fts3OpenTokenizer(

   return rc;
 }
 /*
 ** Function getNextNode(), which is called by fts3ExprParse(), may itself
 ** call fts3ExprParse(). So this forward declaration is required.
 */
 static int fts3ExprParse(ParseContext *, const char *, int, Fts3Expr **, int *);
 /*
 ** Extract the next token from buffer z (length n) using the tokenizer

@@ -128471,7 +131169,31 @@ static int getNextToken(

     int nByte;                               /* total space to allocate */
     rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition);
     if( rc==SQLITE_OK ){
     if( (rc==SQLITE_OK || rc==SQLITE_DONE) && sqlite3_fts3_enable_parentheses ){
       int i;
       if( rc==SQLITE_DONE ) iStart = n;
       for(i=0; i<iStart; i++){
         if( z[i]=='(' ){
           pParse->nNest++;
           rc = fts3ExprParse(pParse, &z[i+1], n-i-1, &pRet, &nConsumed);
           if( rc==SQLITE_OK && !pRet ){
             rc = SQLITE_DONE;
           }
           nConsumed = (int)(i + 1 + nConsumed);
           break;
         }
         if( z[i]==')' ){
           rc = SQLITE_DONE;
           pParse->nNest--;
           nConsumed = i+1;
           break;
         }
       }
     }
     if( nConsumed==0 && rc==SQLITE_OK ){
       nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken;
       pRet = (Fts3Expr *)fts3MallocZero(nByte);
       if( !pRet ){

@@ -128652,12 +131374,6 @@ no_mem:

 }
 /*
 ** Function getNextNode(), which is called by fts3ExprParse(), may itself
 ** call fts3ExprParse(). So this forward declaration is required.
 */
 static int fts3ExprParse(ParseContext *, const char *, int, Fts3Expr **, int *);
 /*
 ** The output variable *ppExpr is populated with an allocated Fts3Expr
 ** structure, or set to 0 if the end of the input buffer is reached.
 **

@@ -128753,27 +131469,6 @@ static int getNextNode(

     }
   }
   /* Check for an open bracket. */
   if( sqlite3_fts3_enable_parentheses ){
     if( *zInput=='(' ){
       int nConsumed;
       pParse->nNest++;
       rc = fts3ExprParse(pParse, &zInput[1], nInput-1, ppExpr, &nConsumed);
       if( rc==SQLITE_OK && !*ppExpr ){
         rc = SQLITE_DONE;
       }
       *pnConsumed = (int)((zInput - z) + 1 + nConsumed);
       return rc;
     }
     /* Check for a close bracket. */
     if( *zInput==')' ){
       pParse->nNest--;
       *pnConsumed = (int)((zInput - z) + 1);
       return SQLITE_DONE;
     }
   }
   /* See if we are dealing with a quoted phrase. If this is the case, then
   ** search for the closing quote and pass the whole string to getNextString()
   ** for processing. This is easy to do, as fts3 has no syntax for escaping

@@ -129657,13 +132352,13 @@ SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash *pH){

 */
 static int fts3StrHash(const void *pKey, int nKey){
   const char *z = (const char *)pKey;
   int h = 0;
   unsigned h = 0;
   if( nKey<=0 ) nKey = (int) strlen(z);
   while( nKey > 0  ){
     h = (h<<3) ^ h ^ *z++;
     nKey--;
   }
   return h & 0x7fffffff;
   return (int)(h & 0x7fffffff);
 }
 static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){
   if( n1!=n2 ) return 1;

@@ -130348,12 +133043,14 @@ static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){

   /* Step 2 */
   switch( z[1] ){
    case 'a':
      stem(&z, "lanoita", "ate", m_gt_0) ||
      stem(&z, "lanoit", "tion", m_gt_0);
      if( !stem(&z, "lanoita", "ate", m_gt_0) ){
        stem(&z, "lanoit", "tion", m_gt_0);
      }
      break;
    case 'c':
      stem(&z, "icne", "ence", m_gt_0) ||
      stem(&z, "icna", "ance", m_gt_0);
      if( !stem(&z, "icne", "ence", m_gt_0) ){
        stem(&z, "icna", "ance", m_gt_0);
      }
      break;
    case 'e':
      stem(&z, "rezi", "ize", m_gt_0);

@@ -130362,43 +133059,54 @@ static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){

      stem(&z, "igol", "log", m_gt_0);
      break;
    case 'l':
      stem(&z, "ilb", "ble", m_gt_0) ||
      stem(&z, "illa", "al", m_gt_0) ||
      stem(&z, "iltne", "ent", m_gt_0) ||
      stem(&z, "ile", "e", m_gt_0) ||
      stem(&z, "ilsuo", "ous", m_gt_0);
      if( !stem(&z, "ilb", "ble", m_gt_0)
       && !stem(&z, "illa", "al", m_gt_0)
       && !stem(&z, "iltne", "ent", m_gt_0)
       && !stem(&z, "ile", "e", m_gt_0)
      ){
        stem(&z, "ilsuo", "ous", m_gt_0);
      }
      break;
    case 'o':
      stem(&z, "noitazi", "ize", m_gt_0) ||
      stem(&z, "noita", "ate", m_gt_0) ||
      stem(&z, "rota", "ate", m_gt_0);
      if( !stem(&z, "noitazi", "ize", m_gt_0)
       && !stem(&z, "noita", "ate", m_gt_0)
      ){
        stem(&z, "rota", "ate", m_gt_0);
      }
      break;
    case 's':
      stem(&z, "msila", "al", m_gt_0) ||
      stem(&z, "ssenevi", "ive", m_gt_0) ||
      stem(&z, "ssenluf", "ful", m_gt_0) ||
      stem(&z, "ssensuo", "ous", m_gt_0);
      if( !stem(&z, "msila", "al", m_gt_0)
       && !stem(&z, "ssenevi", "ive", m_gt_0)
       && !stem(&z, "ssenluf", "ful", m_gt_0)
      ){
        stem(&z, "ssensuo", "ous", m_gt_0);
      }
      break;
    case 't':
      stem(&z, "itila", "al", m_gt_0) ||
      stem(&z, "itivi", "ive", m_gt_0) ||
      stem(&z, "itilib", "ble", m_gt_0);
      if( !stem(&z, "itila", "al", m_gt_0)
       && !stem(&z, "itivi", "ive", m_gt_0)
      ){
        stem(&z, "itilib", "ble", m_gt_0);
      }
      break;
   }
   /* Step 3 */
   switch( z[0] ){
    case 'e':
      stem(&z, "etaci", "ic", m_gt_0) ||
      stem(&z, "evita", "", m_gt_0)   ||
      stem(&z, "ezila", "al", m_gt_0);
      if( !stem(&z, "etaci", "ic", m_gt_0)
       && !stem(&z, "evita", "", m_gt_0)
      ){
        stem(&z, "ezila", "al", m_gt_0);
      }
      break;
    case 'i':
      stem(&z, "itici", "ic", m_gt_0);
      break;
    case 'l':
      stem(&z, "laci", "ic", m_gt_0) ||
      stem(&z, "luf", "", m_gt_0);
      if( !stem(&z, "laci", "ic", m_gt_0) ){
        stem(&z, "luf", "", m_gt_0);
      }
      break;
    case 's':
      stem(&z, "ssen", "", m_gt_0);

@@ -130439,9 +133147,11 @@ static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){

            z += 3;
          }
        }else if( z[2]=='e' ){
          stem(&z, "tneme", "", m_gt_1) ||
          stem(&z, "tnem", "", m_gt_1) ||
          stem(&z, "tne", "", m_gt_1);
          if( !stem(&z, "tneme", "", m_gt_1)
           && !stem(&z, "tnem", "", m_gt_1)
          ){
            stem(&z, "tne", "", m_gt_1);
          }
        }
      }
      break;

@@ -130460,8 +133170,9 @@ static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){

      }
      break;
    case 't':
      stem(&z, "eta", "", m_gt_1) ||
      stem(&z, "iti", "", m_gt_1);
      if( !stem(&z, "eta", "", m_gt_1) ){
        stem(&z, "iti", "", m_gt_1);
      }
      break;
    case 'u':
      if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){

@@ -133118,8 +135829,8 @@ static int fts3SegReaderNext(

   /* Because of the FTS3_NODE_PADDING bytes of padding, the following is
   ** safe (no risk of overread) even if the node data is corrupted. */
   pNext += sqlite3Fts3GetVarint32(pNext, &nPrefix);
   pNext += sqlite3Fts3GetVarint32(pNext, &nSuffix);
   pNext += fts3GetVarint32(pNext, &nPrefix);
   pNext += fts3GetVarint32(pNext, &nSuffix);
   if( nPrefix<0 || nSuffix<=0
    || &pNext[nSuffix]>&pReader->aNode[pReader->nNode]
   ){

@@ -133142,7 +135853,7 @@ static int fts3SegReaderNext(

   memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
   pReader->nTerm = nPrefix+nSuffix;
   pNext += nSuffix;
   pNext += sqlite3Fts3GetVarint32(pNext, &pReader->nDoclist);
   pNext += fts3GetVarint32(pNext, &pReader->nDoclist);
   pReader->aDoclist = pNext;
   pReader->pOffsetList = 0;

@@ -134303,7 +137014,7 @@ static void fts3ColumnFilter(

       break;
     }
     p = &pList[1];
     p += sqlite3Fts3GetVarint32(p, &iCurrent);
     p += fts3GetVarint32(p, &iCurrent);
   }
   if( bZero && &pList[nList]!=pEnd ){

@@ -135268,9 +137979,9 @@ static int nodeReaderNext(NodeReader *p){

     p->aNode = 0;
   }else{
     if( bFirst==0 ){
       p->iOff += sqlite3Fts3GetVarint32(&p->aNode[p->iOff], &nPrefix);
       p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nPrefix);
     }
     p->iOff += sqlite3Fts3GetVarint32(&p->aNode[p->iOff], &nSuffix);
     p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nSuffix);
     blobGrowBuffer(&p->term, nPrefix+nSuffix, &rc);
     if( rc==SQLITE_OK ){

@@ -135278,7 +137989,7 @@ static int nodeReaderNext(NodeReader *p){

       p->term.n = nPrefix+nSuffix;
       p->iOff += nSuffix;
       if( p->iChild==0 ){
         p->iOff += sqlite3Fts3GetVarint32(&p->aNode[p->iOff], &p->nDoclist);
         p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &p->nDoclist);
         p->aDoclist = &p->aNode[p->iOff];
         p->iOff += p->nDoclist;
       }

@@ -136330,7 +139041,7 @@ static int fts3IncrmergeHintPop(Blob *pHint, i64 *piAbsLevel, int *pnInput){

   pHint->n = i;
   i += sqlite3Fts3GetVarint(&pHint->a[i], piAbsLevel);
   i += sqlite3Fts3GetVarint32(&pHint->a[i], pnInput);
   i += fts3GetVarint32(&pHint->a[i], pnInput);
   if( i!=nHint ) return SQLITE_CORRUPT_VTAB;
   return SQLITE_OK;

@@ -137323,7 +140034,7 @@ struct StrBuffer {

 */
 static void fts3GetDeltaPosition(char **pp, int *piPos){
   int iVal;
   *pp += sqlite3Fts3GetVarint32(*pp, &iVal);
   *pp += fts3GetVarint32(*pp, &iVal);
   *piPos += (iVal-2);
 }

@@ -139616,6 +142327,16 @@ typedef union RtreeCoord RtreeCoord;

 */
 #define HASHSIZE 128
 /* The xBestIndex method of this virtual table requires an estimate of
 ** the number of rows in the virtual table to calculate the costs of
 ** various strategies. If possible, this estimate is loaded from the
 ** sqlite_stat1 table (with RTREE_MIN_ROWEST as a hard-coded minimum).
 ** Otherwise, if no sqlite_stat1 entry is available, use
 ** RTREE_DEFAULT_ROWEST.
 */
 #define RTREE_DEFAULT_ROWEST 1048576
 #define RTREE_MIN_ROWEST         100
 /*
 ** An rtree virtual-table object.
 */

@@ -139630,6 +142351,7 @@ struct Rtree {

   char *zName;                /* Name of r-tree table */
   RtreeNode *aHash[HASHSIZE]; /* Hash table of in-memory nodes. */
   int nBusy;                  /* Current number of users of this structure */
   i64 nRowEst;                /* Estimated number of rows in this table */
   /* List of nodes removed during a CondenseTree operation. List is
   ** linked together via the pointer normally used for hash chains -

@@ -140823,6 +143545,19 @@ static int rtreeFilter(

 }
 /*
 ** Set the pIdxInfo->estimatedRows variable to nRow. Unless this
 ** extension is currently being used by a version of SQLite too old to
 ** support estimatedRows. In that case this function is a no-op.
 */
 static void setEstimatedRows(sqlite3_index_info *pIdxInfo, i64 nRow){
 #if SQLITE_VERSION_NUMBER>=3008002
   if( sqlite3_libversion_number()>=3008002 ){
     pIdxInfo->estimatedRows = nRow;
   }
 #endif
 }
 /*
 ** Rtree virtual table module xBestIndex method. There are three
 ** table scan strategies to choose from (in order from most to
 ** least desirable):

@@ -140857,13 +143592,14 @@ static int rtreeFilter(

 ** is 'a', the second from the left 'b' etc.
 */
 static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
   Rtree *pRtree = (Rtree*)tab;
   int rc = SQLITE_OK;
   int ii;
   i64 nRow;                       /* Estimated rows returned by this scan */
   int iIdx = 0;
   char zIdxStr[RTREE_MAX_DIMENSIONS*8+1];
   memset(zIdxStr, 0, sizeof(zIdxStr));
   UNUSED_PARAMETER(tab);
   assert( pIdxInfo->idxStr==0 );
   for(ii=0; ii<pIdxInfo->nConstraint && iIdx<(int)(sizeof(zIdxStr)-1); ii++){

@@ -140883,9 +143619,11 @@ static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){

       /* This strategy involves a two rowid lookups on an B-Tree structures
       ** and then a linear search of an R-Tree node. This should be
       ** considered almost as quick as a direct rowid lookup (for which
       ** sqlite uses an internal cost of 0.0).
       ** sqlite uses an internal cost of 0.0). It is expected to return
       ** a single row.
       */
       pIdxInfo->estimatedCost = 10.0;
       pIdxInfo->estimatedCost = 30.0;
       setEstimatedRows(pIdxInfo, 1);
       return SQLITE_OK;
     }

@@ -140914,8 +143652,11 @@ static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){

   if( iIdx>0 && 0==(pIdxInfo->idxStr = sqlite3_mprintf("%s", zIdxStr)) ){
     return SQLITE_NOMEM;
   }
   assert( iIdx>=0 );
   pIdxInfo->estimatedCost = (2000000.0 / (double)(iIdx + 1));
   nRow = pRtree->nRowEst / (iIdx + 1);
   pIdxInfo->estimatedCost = (double)6.0 * (double)nRow;
   setEstimatedRows(pIdxInfo, nRow);
   return rc;
 }

@@ -142390,6 +145131,37 @@ static int rtreeRename(sqlite3_vtab *pVtab, const char *zNewName){

   return rc;
 }
 /*
 ** This function populates the pRtree->nRowEst variable with an estimate
 ** of the number of rows in the virtual table. If possible, this is based
 ** on sqlite_stat1 data. Otherwise, use RTREE_DEFAULT_ROWEST.
 */
 static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){
   const char *zSql = "SELECT stat FROM sqlite_stat1 WHERE tbl= ? || '_rowid'";
   sqlite3_stmt *p;
   int rc;
   i64 nRow = 0;
   rc = sqlite3_prepare_v2(db, zSql, -1, &p, 0);
   if( rc==SQLITE_OK ){
     sqlite3_bind_text(p, 1, pRtree->zName, -1, SQLITE_STATIC);
     if( sqlite3_step(p)==SQLITE_ROW ) nRow = sqlite3_column_int64(p, 0);
     rc = sqlite3_finalize(p);
   }else if( rc!=SQLITE_NOMEM ){
     rc = SQLITE_OK;
   }
   if( rc==SQLITE_OK ){
     if( nRow==0 ){
       pRtree->nRowEst = RTREE_DEFAULT_ROWEST;
     }else{
       pRtree->nRowEst = MAX(nRow, RTREE_MIN_ROWEST);
     }
   }
   return rc;
 }
 static sqlite3_module rtreeModule = {
 ,                          /* iVersion */
   rtreeCreate,                /* xCreate - create a table */

@@ -142475,6 +145247,7 @@ static int rtreeSqlInit(

   appStmt[7] = &pRtree->pWriteParent;
   appStmt[8] = &pRtree->pDeleteParent;
   rc = rtreeQueryStat1(db, pRtree);
   for(i=0; i<N_STATEMENT && rc==SQLITE_OK; i++){
     char *zSql = sqlite3_mprintf(azSql[i], zDb, zPrefix);
     if( zSql ){

modified external/sqlite/sqlite3.h

@@ -107,9 +107,9 @@ extern "C" {

 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
 #define SQLITE_VERSION        "3.8.1"
 #define SQLITE_VERSION_NUMBER 3008001
 #define SQLITE_SOURCE_ID      "2013-10-17 12:57:35 c78be6d786c19073b3a6730dfe3fb1be54f5657a"
 #define SQLITE_VERSION        "3.8.4.1"
 #define SQLITE_VERSION_NUMBER 3008004
 #define SQLITE_SOURCE_ID      "2014-03-11 15:27:36 018d317b1257ce68a92908b05c9c7cf1494050d0"
 /*
 ** CAPI3REF: Run-Time Library Version Numbers

@@ -370,7 +370,7 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);

 ** <ul>
 ** <li> The application must insure that the 1st parameter to sqlite3_exec()
 **      is a valid and open [database connection].
 ** <li> The application must not close [database connection] specified by
 ** <li> The application must not close the [database connection] specified by
 **      the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
 ** <li> The application must not modify the SQL statement text passed into
 **      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.

@@ -447,7 +447,7 @@ SQLITE_API int sqlite3_exec(

 ** [sqlite3_extended_result_codes()] API.
 **
 ** Some of the available extended result codes are listed here.
 ** One may expect the number of extended result codes will be expand
 ** One may expect the number of extended result codes will increase
 ** over time.  Software that uses extended result codes should expect
 ** to see new result codes in future releases of SQLite.
 **

@@ -491,6 +491,7 @@ SQLITE_API int sqlite3_exec(

 #define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
 #define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
 #define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
 #define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
 #define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
 #define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
 #define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))

@@ -501,6 +502,7 @@ SQLITE_API int sqlite3_exec(

 #define SQLITE_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))
 #define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))
 #define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))
 #define SQLITE_CONSTRAINT_ROWID        (SQLITE_CONSTRAINT |(10<<8))
 #define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
 #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
 #define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))

@@ -557,7 +559,8 @@ SQLITE_API int sqlite3_exec(

 ** after reboot following a crash or power loss, the only bytes in a
 ** file that were written at the application level might have changed
 ** and that adjacent bytes, even bytes within the same sector are
 ** guaranteed to be unchanged.
 ** guaranteed to be unchanged.  The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
 ** flag indicate that a file cannot be deleted when open.
 */
 #define SQLITE_IOCAP_ATOMIC                 0x00000001
 #define SQLITE_IOCAP_ATOMIC512              0x00000002

@@ -788,15 +791,29 @@ struct sqlite3_io_methods {

 ** additional information.
 **
 ** <li>[[SQLITE_FCNTL_SYNC_OMITTED]]
 ** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by
 ** SQLite and sent to all VFSes in place of a call to the xSync method
 ** when the database connection has [PRAGMA synchronous] set to OFF.)^
 ** Some specialized VFSes need this signal in order to operate correctly
 ** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most
 ** VFSes do not need this signal and should silently ignore this opcode.
 ** Applications should not call [sqlite3_file_control()] with this
 ** opcode as doing so may disrupt the operation of the specialized VFSes
 ** that do require it.
 ** No longer in use.
 **
 ** <li>[[SQLITE_FCNTL_SYNC]]
 ** The [SQLITE_FCNTL_SYNC] opcode is generated internally by SQLite and
 ** sent to the VFS immediately before the xSync method is invoked on a
 ** database file descriptor. Or, if the xSync method is not invoked
 ** because the user has configured SQLite with
 ** [PRAGMA synchronous | PRAGMA synchronous=OFF] it is invoked in place
 ** of the xSync method. In most cases, the pointer argument passed with
 ** this file-control is NULL. However, if the database file is being synced
 ** as part of a multi-database commit, the argument points to a nul-terminated
 ** string containing the transactions master-journal file name. VFSes that
 ** do not need this signal should silently ignore this opcode. Applications
 ** should not call [sqlite3_file_control()] with this opcode as doing so may
 ** disrupt the operation of the specialized VFSes that do require it.
 **
 ** <li>[[SQLITE_FCNTL_COMMIT_PHASETWO]]
 ** The [SQLITE_FCNTL_COMMIT_PHASETWO] opcode is generated internally by SQLite
 ** and sent to the VFS after a transaction has been committed immediately
 ** but before the database is unlocked. VFSes that do not need this signal
 ** should silently ignore this opcode. Applications should not call
 ** [sqlite3_file_control()] with this opcode as doing so may disrupt the
 ** operation of the specialized VFSes that do require it.
 **
 ** <li>[[SQLITE_FCNTL_WIN32_AV_RETRY]]
 ** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic

@@ -912,6 +929,20 @@ struct sqlite3_io_methods {

 ** can be queried by passing in a pointer to a negative number.  This
 ** file-control is used internally to implement [PRAGMA mmap_size].
 **
 ** <li>[[SQLITE_FCNTL_TRACE]]
 ** The [SQLITE_FCNTL_TRACE] file control provides advisory information
 ** to the VFS about what the higher layers of the SQLite stack are doing.
 ** This file control is used by some VFS activity tracing [shims].
 ** The argument is a zero-terminated string.  Higher layers in the
 ** SQLite stack may generate instances of this file control if
 ** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled.
 **
 ** <li>[[SQLITE_FCNTL_HAS_MOVED]]
 ** The [SQLITE_FCNTL_HAS_MOVED] file control interprets its argument as a
 ** pointer to an integer and it writes a boolean into that integer depending
 ** on whether or not the file has been renamed, moved, or deleted since it
 ** was first opened.
 **
 ** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1

@@ -931,6 +962,10 @@ struct sqlite3_io_methods {

 #define SQLITE_FCNTL_BUSYHANDLER            15
 #define SQLITE_FCNTL_TEMPFILENAME           16
 #define SQLITE_FCNTL_MMAP_SIZE              18
 #define SQLITE_FCNTL_TRACE                  19
 #define SQLITE_FCNTL_HAS_MOVED              20
 #define SQLITE_FCNTL_SYNC                   21
 #define SQLITE_FCNTL_COMMIT_PHASETWO        22
 /*
 ** CAPI3REF: Mutex Handle

@@ -1375,7 +1410,7 @@ SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...);

 ** or [sqlite3_realloc()] first calls xRoundup.  If xRoundup returns 0,
 ** that causes the corresponding memory allocation to fail.
 **
 ** The xInit method initializes the memory allocator.  (For example,
 ** The xInit method initializes the memory allocator.  For example,
 ** it might allocate any require mutexes or initialize internal data
 ** structures.  The xShutdown method is invoked (indirectly) by
 ** [sqlite3_shutdown()] and should deallocate any resources acquired

@@ -1677,6 +1712,13 @@ struct sqlite3_mem_methods {

 ** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^
 ** ^If either argument to this option is negative, then that argument is
 ** changed to its compile-time default.
 **
 ** [[SQLITE_CONFIG_WIN32_HEAPSIZE]]
 ** <dt>SQLITE_CONFIG_WIN32_HEAPSIZE
 ** <dd>^This option is only available if SQLite is compiled for Windows
 ** with the [SQLITE_WIN32_MALLOC] pre-processor macro defined.
 ** SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
 ** that specifies the maximum size of the created heap.
 ** </dl>
 */
 #define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */

@@ -1701,6 +1743,7 @@ struct sqlite3_mem_methods {

 #define SQLITE_CONFIG_COVERING_INDEX_SCAN 20  /* int */
 #define SQLITE_CONFIG_SQLLOG       21  /* xSqllog, void* */
 #define SQLITE_CONFIG_MMAP_SIZE    22  /* sqlite3_int64, sqlite3_int64 */
 #define SQLITE_CONFIG_WIN32_HEAPSIZE      23  /* int nByte */
 /*
 ** CAPI3REF: Database Connection Configuration Options

@@ -1777,19 +1820,21 @@ SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);

 /*
 ** CAPI3REF: Last Insert Rowid
 **
 ** ^Each entry in an SQLite table has a unique 64-bit signed
 ** ^Each entry in most SQLite tables (except for [WITHOUT ROWID] tables)
 ** has a unique 64-bit signed
 ** integer key called the [ROWID | "rowid"]. ^The rowid is always available
 ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
 ** names are not also used by explicitly declared columns. ^If
 ** the table has a column of type [INTEGER PRIMARY KEY] then that column
 ** is another alias for the rowid.
 **
 ** ^This routine returns the [rowid] of the most recent
 ** successful [INSERT] into the database from the [database connection]
 ** in the first argument.  ^As of SQLite version 3.7.7, this routines
 ** records the last insert rowid of both ordinary tables and [virtual tables].
 ** ^If no successful [INSERT]s
 ** have ever occurred on that database connection, zero is returned.
 ** ^The sqlite3_last_insert_rowid(D) interface returns the [rowid] of the
 ** most recent successful [INSERT] into a rowid table or [virtual table]
 ** on database connection D.
 ** ^Inserts into [WITHOUT ROWID] tables are not recorded.
 ** ^If no successful [INSERT]s into rowid tables
 ** have ever occurred on the database connection D,
 ** then sqlite3_last_insert_rowid(D) returns zero.
 **
 ** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
 ** method, then this routine will return the [rowid] of the inserted

@@ -2355,11 +2400,13 @@ SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);

 ** applications to access the same PRNG for other purposes.
 **
 ** ^A call to this routine stores N bytes of randomness into buffer P.
 ** ^If N is less than one, then P can be a NULL pointer.
 **
 ** ^The first time this routine is invoked (either internally or by
 ** the application) the PRNG is seeded using randomness obtained
 ** from the xRandomness method of the default [sqlite3_vfs] object.
 ** ^On all subsequent invocations, the pseudo-randomness is generated
 ** ^If this routine has not been previously called or if the previous
 ** call had N less than one, then the PRNG is seeded using randomness
 ** obtained from the xRandomness method of the default [sqlite3_vfs] object.
 ** ^If the previous call to this routine had an N of 1 or more then
 ** the pseudo-randomness is generated
 ** internally and without recourse to the [sqlite3_vfs] xRandomness
 ** method.
 */

@@ -2519,6 +2566,7 @@ SQLITE_API int sqlite3_set_authorizer(

 #define SQLITE_FUNCTION             31   /* NULL            Function Name   */
 #define SQLITE_SAVEPOINT            32   /* Operation       Savepoint Name  */
 #define SQLITE_COPY                  0   /* No longer used */
 #define SQLITE_RECURSIVE            33   /* NULL            NULL            */
 /*
 ** CAPI3REF: Tracing And Profiling Functions

@@ -3099,7 +3147,6 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);

 ** choice of query plan if the parameter is the left-hand side of a [LIKE]
 ** or [GLOB] operator or if the parameter is compared to an indexed column
 ** and the [SQLITE_ENABLE_STAT3] compile-time option is enabled.
 ** the
 ** </li>
 ** </ol>
 */

@@ -3761,19 +3808,19 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);

 **
 ** <tr><td>  NULL    <td> INTEGER   <td> Result is 0
 ** <tr><td>  NULL    <td>  FLOAT    <td> Result is 0.0
 ** <tr><td>  NULL    <td>   TEXT    <td> Result is NULL pointer
 ** <tr><td>  NULL    <td>   BLOB    <td> Result is NULL pointer
 ** <tr><td>  NULL    <td>   TEXT    <td> Result is a NULL pointer
 ** <tr><td>  NULL    <td>   BLOB    <td> Result is a NULL pointer
 ** <tr><td> INTEGER  <td>  FLOAT    <td> Convert from integer to float
 ** <tr><td> INTEGER  <td>   TEXT    <td> ASCII rendering of the integer
 ** <tr><td> INTEGER  <td>   BLOB    <td> Same as INTEGER->TEXT
 ** <tr><td>  FLOAT   <td> INTEGER   <td> Convert from float to integer
 ** <tr><td>  FLOAT   <td> INTEGER   <td> [CAST] to INTEGER
 ** <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
 ** <tr><td>  FLOAT   <td>   BLOB    <td> Same as FLOAT->TEXT
 ** <tr><td>  TEXT    <td> INTEGER   <td> Use atoi()
 ** <tr><td>  TEXT    <td>  FLOAT    <td> Use atof()
 ** <tr><td>  FLOAT   <td>   BLOB    <td> [CAST] to BLOB
 ** <tr><td>  TEXT    <td> INTEGER   <td> [CAST] to INTEGER
 ** <tr><td>  TEXT    <td>  FLOAT    <td> [CAST] to REAL
 ** <tr><td>  TEXT    <td>   BLOB    <td> No change
 ** <tr><td>  BLOB    <td> INTEGER   <td> Convert to TEXT then use atoi()
 ** <tr><td>  BLOB    <td>  FLOAT    <td> Convert to TEXT then use atof()
 ** <tr><td>  BLOB    <td> INTEGER   <td> [CAST] to INTEGER
 ** <tr><td>  BLOB    <td>  FLOAT    <td> [CAST] to REAL
 ** <tr><td>  BLOB    <td>   TEXT    <td> Add a zero terminator if needed
 ** </table>
 ** </blockquote>)^

@@ -3829,7 +3876,7 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);

 ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
 ** [sqlite3_finalize()] is called.  ^The memory space used to hold strings
 ** and BLOBs is freed automatically.  Do <b>not</b> pass the pointers returned
 ** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
 ** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
 ** [sqlite3_free()].
 **
 ** ^(If a memory allocation error occurs during the evaluation of any

@@ -3938,15 +3985,24 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);

 **
 ** ^The fourth parameter, eTextRep, specifies what
 ** [SQLITE_UTF8 | text encoding] this SQL function prefers for
 ** its parameters.  Every SQL function implementation must be able to work
 ** with UTF-8, UTF-16le, or UTF-16be.  But some implementations may be
 ** more efficient with one encoding than another.  ^An application may
 ** invoke sqlite3_create_function() or sqlite3_create_function16() multiple
 ** times with the same function but with different values of eTextRep.
 ** its parameters.  The application should set this parameter to
 ** [SQLITE_UTF16LE] if the function implementation invokes
 ** [sqlite3_value_text16le()] on an input, or [SQLITE_UTF16BE] if the
 ** implementation invokes [sqlite3_value_text16be()] on an input, or
 ** [SQLITE_UTF16] if [sqlite3_value_text16()] is used, or [SQLITE_UTF8]
 ** otherwise.  ^The same SQL function may be registered multiple times using
 ** different preferred text encodings, with different implementations for
 ** each encoding.
 ** ^When multiple implementations of the same function are available, SQLite
 ** will pick the one that involves the least amount of data conversion.
 ** If there is only a single implementation which does not care what text
 ** encoding is used, then the fourth argument should be [SQLITE_ANY].
 **
 ** ^The fourth parameter may optionally be ORed with [SQLITE_DETERMINISTIC]
 ** to signal that the function will always return the same result given
 ** the same inputs within a single SQL statement.  Most SQL functions are
 ** deterministic.  The built-in [random()] SQL function is an example of a
 ** function that is not deterministic.  The SQLite query planner is able to
 ** perform additional optimizations on deterministic functions, so use
 ** of the [SQLITE_DETERMINISTIC] flag is recommended where possible.
 **
 ** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
 ** function can gain access to this pointer using [sqlite3_user_data()].)^

@@ -4032,10 +4088,20 @@ SQLITE_API int sqlite3_create_function_v2(

 #define SQLITE_UTF16LE        2
 #define SQLITE_UTF16BE        3
 #define SQLITE_UTF16          4    /* Use native byte order */
 #define SQLITE_ANY            5    /* sqlite3_create_function only */
 #define SQLITE_ANY            5    /* Deprecated */
 #define SQLITE_UTF16_ALIGNED  8    /* sqlite3_create_collation only */
 /*
 ** CAPI3REF: Function Flags
 **
 ** These constants may be ORed together with the
 ** [SQLITE_UTF8 | preferred text encoding] as the fourth argument
 ** to [sqlite3_create_function()], [sqlite3_create_function16()], or
 ** [sqlite3_create_function_v2()].
 */
 #define SQLITE_DETERMINISTIC    0x800
 /*
 ** CAPI3REF: Deprecated Functions
 ** DEPRECATED
 **

@@ -4806,12 +4872,13 @@ SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);

 **
 ** ^The sqlite3_update_hook() interface registers a callback function
 ** with the [database connection] identified by the first argument
 ** to be invoked whenever a row is updated, inserted or deleted.
 ** to be invoked whenever a row is updated, inserted or deleted in
 ** a rowid table.
 ** ^Any callback set by a previous call to this function
 ** for the same database connection is overridden.
 **
 ** ^The second argument is a pointer to the function to invoke when a
 ** row is updated, inserted or deleted.
 ** row is updated, inserted or deleted in a rowid table.
 ** ^The first argument to the callback is a copy of the third argument
 ** to sqlite3_update_hook().
 ** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE],

@@ -4824,6 +4891,7 @@ SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);

 **
 ** ^(The update hook is not invoked when internal system tables are
 ** modified (i.e. sqlite_master and sqlite_sequence).)^
 ** ^The update hook is not invoked when [WITHOUT ROWID] tables are modified.
 **
 ** ^In the current implementation, the update hook
 ** is not invoked when duplication rows are deleted because of an

@@ -4905,8 +4973,8 @@ SQLITE_API int sqlite3_release_memory(int);

 **
 ** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap
 ** memory as possible from database connection D. Unlike the
 ** [sqlite3_release_memory()] interface, this interface is effect even
 ** when then [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
 ** [sqlite3_release_memory()] interface, this interface is in effect even
 ** when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
 ** omitted.
 **
 ** See also: [sqlite3_release_memory()]

@@ -5281,10 +5349,22 @@ struct sqlite3_module {

 ** the correct order to satisfy the ORDER BY clause so that no separate
 ** sorting step is required.
 **
 ** ^The estimatedCost value is an estimate of the cost of doing the
 ** particular lookup.  A full scan of a table with N entries should have
 ** a cost of N.  A binary search of a table of N entries should have a
 ** cost of approximately log(N).
 ** ^The estimatedCost value is an estimate of the cost of a particular
 ** strategy. A cost of N indicates that the cost of the strategy is similar
 ** to a linear scan of an SQLite table with N rows. A cost of log(N)
 ** indicates that the expense of the operation is similar to that of a
 ** binary search on a unique indexed field of an SQLite table with N rows.
 **
 ** ^The estimatedRows value is an estimate of the number of rows that
 ** will be returned by the strategy.
 **
 ** IMPORTANT: The estimatedRows field was added to the sqlite3_index_info
 ** structure for SQLite version 3.8.2. If a virtual table extension is
 ** used with an SQLite version earlier than 3.8.2, the results of attempting
 ** to read or write the estimatedRows field are undefined (but are likely
 ** to included crashing the application). The estimatedRows field should
 ** therefore only be used if [sqlite3_libversion_number()] returns a
 ** value greater than or equal to 3008002.
 */
 struct sqlite3_index_info {
   /* Inputs */

@@ -5309,7 +5389,9 @@ struct sqlite3_index_info {

   char *idxStr;              /* String, possibly obtained from sqlite3_malloc */
   int needToFreeIdxStr;      /* Free idxStr using sqlite3_free() if true */
   int orderByConsumed;       /* True if output is already ordered */
   double estimatedCost;      /* Estimated cost of using this index */
   double estimatedCost;           /* Estimated cost of using this index */
   /* Fields below are only available in SQLite 3.8.2 and later */
   sqlite3_int64 estimatedRows;    /* Estimated number of rows returned */
 };
 /*

@@ -5513,6 +5595,9 @@ typedef struct sqlite3_blob sqlite3_blob;

 ** interface.  Use the [UPDATE] SQL command to change the size of a
 ** blob.
 **
 ** ^The [sqlite3_blob_open()] interface will fail for a [WITHOUT ROWID]
 ** table.  Incremental BLOB I/O is not possible on [WITHOUT ROWID] tables.
 **
 ** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces
 ** and the built-in [zeroblob] SQL function can be used, if desired,
 ** to create an empty, zero-filled blob in which to read or write using

@@ -6036,7 +6121,9 @@ SQLITE_API int sqlite3_test_control(int op, ...);

 #define SQLITE_TESTCTRL_SCRATCHMALLOC           17
 #define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
 #define SQLITE_TESTCTRL_EXPLAIN_STMT            19
 #define SQLITE_TESTCTRL_LAST                    19
 #define SQLITE_TESTCTRL_NEVER_CORRUPT           20
 #define SQLITE_TESTCTRL_VDBE_COVERAGE           21
 #define SQLITE_TESTCTRL_LAST                    21
 /*
 ** CAPI3REF: SQLite Runtime Status