Fossil

#  define mkdir(path,mode) _mkdir(path)
#  define lstat(path,buf) stat(path,buf)
#endif
#include <time.h>
#include <errno.h>






#define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)"








/*
** Set the result stored by context ctx to a blob containing the 
** contents of file zName.
*/
static void readFileContents(sqlite3_context *ctx, const char *zName){
  FILE *in;
................................................................................
static int fsdirColumn(
  sqlite3_vtab_cursor *cur,   /* The cursor */
  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */
  int i                       /* Which column to return */
){
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
  switch( i ){
    case 0: { /* name */
      sqlite3_result_text(ctx, &pCur->zPath[pCur->nBase], -1, SQLITE_TRANSIENT);
      break;
    }

    case 1: /* mode */
      sqlite3_result_int64(ctx, pCur->sStat.st_mode);
      break;

    case 2: /* mtime */
      sqlite3_result_int64(ctx, pCur->sStat.st_mtime);
      break;

    case 3: { /* data */
      mode_t m = pCur->sStat.st_mode;
      if( S_ISDIR(m) ){
        sqlite3_result_null(ctx);
#if !defined(_WIN32) && !defined(WIN32)
      }else if( S_ISLNK(m) ){
        char aStatic[64];
        char *aBuf = aStatic;
................................................................................
        sqlite3_result_text(ctx, aBuf, n, SQLITE_TRANSIENT);
        if( aBuf!=aStatic ) sqlite3_free(aBuf);
#endif
      }else{
        readFileContents(ctx, pCur->zPath);
      }
    }






  }
  return SQLITE_OK;
}

/*
** Return the rowid for the current row. In this implementation, the
** first row returned is assigned rowid value 1, and each subsequent
................................................................................
static int fsdirEof(sqlite3_vtab_cursor *cur){
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
  return (pCur->zPath==0);
}

/*
** xFilter callback.



*/
static int fsdirFilter(
  sqlite3_vtab_cursor *cur, 
  int idxNum, const char *idxStr,
  int argc, sqlite3_value **argv
){
  const char *zDir = 0;
................................................................................
** that uses the generate_series virtual table.  This routine needs to create
** a query plan for each invocation and compute an estimated cost for that
** plan.
**
** In this implementation idxNum is used to represent the
** query plan.  idxStr is unused.
**
** The query plan is represented by bits in idxNum:
**
**  (1)  start = $value  -- constraint exists
**  (2)  stop = $value   -- constraint exists
**  (4)  step = $value   -- constraint exists
**  (8)  output in descending order
*/
static int fsdirBestIndex(
  sqlite3_vtab *tab,
  sqlite3_index_info *pIdxInfo
){
  int i;                 /* Loop over constraints */
  int idx4 = -1;
  int idx5 = -1;


  const struct sqlite3_index_constraint *pConstraint;

  (void)tab;
  pConstraint = pIdxInfo->aConstraint;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
    if( pConstraint->usable==0 ) continue;
    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    if( pConstraint->iColumn==4 ) idx4 = i;

    if( pConstraint->iColumn==5 ) idx5 = i;




  }


















  if( idx4<0 ){
    pIdxInfo->idxNum = 0;


    pIdxInfo->estimatedCost = (double)(((sqlite3_int64)1) << 50);
  }else{
    pIdxInfo->aConstraintUsage[idx4].omit = 1;
    pIdxInfo->aConstraintUsage[idx4].argvIndex = 1;
    if( idx5>=0 ){
      pIdxInfo->aConstraintUsage[idx5].omit = 1;
      pIdxInfo->aConstraintUsage[idx5].argvIndex = 2;
      pIdxInfo->idxNum = 2;
      pIdxInfo->estimatedCost = 10.0;
    }else{
      pIdxInfo->idxNum = 1;
      pIdxInfo->estimatedCost = 100.0;
    }
  }
................................................................................
** xBestIndex callback.
*/
static int zipfileBestIndex(
  sqlite3_vtab *tab,
  sqlite3_index_info *pIdxInfo
){
  int i;



  for(i=0; i<pIdxInfo->nConstraint; i++){
    const struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i];

    if( pCons->usable==0 ) continue;

    if( pCons->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    if( pCons->iColumn!=ZIPFILE_F_COLUMN_IDX ) continue;
    break;

  }

  if( i<pIdxInfo->nConstraint ){

    pIdxInfo->aConstraintUsage[i].argvIndex = 1;
    pIdxInfo->aConstraintUsage[i].omit = 1;
    pIdxInfo->estimatedCost = 1000.0;
    pIdxInfo->idxNum = 1;
  }else{
    pIdxInfo->estimatedCost = (double)(((sqlite3_int64)1) << 50);
    pIdxInfo->idxNum = 0;
  }

  return SQLITE_OK;
}

static ZipfileEntry *zipfileNewEntry(const char *zPath){
  ZipfileEntry *pNew;
  pNew = sqlite3_malloc(sizeof(ZipfileEntry));
  if( pNew ){
................................................................................
      { "always",             SQLITE_TESTCTRL_ALWAYS,        "BOOLEAN"            },
      { "assert",             SQLITE_TESTCTRL_ASSERT,        "BOOLEAN"            },
    /*{ "benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, ""          },*/
    /*{ "bitvec_test",        SQLITE_TESTCTRL_BITVEC_TEST,   ""                },*/
      { "byteorder",          SQLITE_TESTCTRL_BYTEORDER,     ""                   },
    /*{ "fault_install",      SQLITE_TESTCTRL_FAULT_INSTALL, ""                }, */
      { "imposter",           SQLITE_TESTCTRL_IMPOSTER,   "SCHEMA ON/OFF ROOTPAGE"},

      { "localtime_fault",    SQLITE_TESTCTRL_LOCALTIME_FAULT,"BOOLEAN"           },
      { "never_corrupt",      SQLITE_TESTCTRL_NEVER_CORRUPT, "BOOLEAN"            },
      { "optimizations",      SQLITE_TESTCTRL_OPTIMIZATIONS, "DISABLE-MASK"       },
#ifdef YYCOVERAGE
      { "parser_coverage",    SQLITE_TESTCTRL_PARSER_COVERAGE, ""                 },
#endif
      { "pending_byte",       SQLITE_TESTCTRL_PENDING_BYTE,  "OFFSET  "           },
................................................................................
            isOk = 3;
          }
          break;

        /* sqlite3_test_control(int, int) */
        case SQLITE_TESTCTRL_ASSERT:
        case SQLITE_TESTCTRL_ALWAYS:

          if( nArg==3 ){
            int opt = booleanValue(azArg[2]);
            rc2 = sqlite3_test_control(testctrl, opt);
            isOk = 1;
          }
          break;

................................................................................
/*
** We need a default sqlite3_complete() implementation to use in case
** the shell is compiled with SQLITE_OMIT_COMPLETE.  The default assumes
** any arbitrary text is a complete SQL statement.  This is not very
** user-friendly, but it does seem to work.
*/
#ifdef SQLITE_OMIT_COMPLETE
int sqlite3_complete(const char *zSql){ return 1; }
#endif

/*
** Return true if zSql is a complete SQL statement.  Return false if it
** ends in the middle of a string literal or C-style comment.
*/
static int line_is_complete(char *zSql, int nSql){

#  define mkdir(path,mode) _mkdir(path)
#  define lstat(path,buf) stat(path,buf)
#endif
#include <time.h>
#include <errno.h>


/*
** Structure of the fsdir() table-valued function
*/
                 /*    0    1    2     3    4           5             */
#define FSDIR_SCHEMA "(name,mode,mtime,data,path HIDDEN,dir HIDDEN)"
#define FSDIR_COLUMN_NAME     0     /* Name of the file */
#define FSDIR_COLUMN_MODE     1     /* Access mode */
#define FSDIR_COLUMN_MTIME    2     /* Last modification time */
#define FSDIR_COLUMN_DATA     3     /* File content */
#define FSDIR_COLUMN_PATH     4     /* Path to top of search */
#define FSDIR_COLUMN_DIR      5     /* Path is relative to this directory */


/*
** Set the result stored by context ctx to a blob containing the 
** contents of file zName.
*/
static void readFileContents(sqlite3_context *ctx, const char *zName){
  FILE *in;
................................................................................
static int fsdirColumn(
  sqlite3_vtab_cursor *cur,   /* The cursor */
  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */
  int i                       /* Which column to return */
){
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
  switch( i ){
    case FSDIR_COLUMN_NAME: {
      sqlite3_result_text(ctx, &pCur->zPath[pCur->nBase], -1, SQLITE_TRANSIENT);
      break;
    }

    case FSDIR_COLUMN_MODE:
      sqlite3_result_int64(ctx, pCur->sStat.st_mode);
      break;

    case FSDIR_COLUMN_MTIME:
      sqlite3_result_int64(ctx, pCur->sStat.st_mtime);
      break;

    case FSDIR_COLUMN_DATA: {
      mode_t m = pCur->sStat.st_mode;
      if( S_ISDIR(m) ){
        sqlite3_result_null(ctx);
#if !defined(_WIN32) && !defined(WIN32)
      }else if( S_ISLNK(m) ){
        char aStatic[64];
        char *aBuf = aStatic;
................................................................................
        sqlite3_result_text(ctx, aBuf, n, SQLITE_TRANSIENT);
        if( aBuf!=aStatic ) sqlite3_free(aBuf);
#endif
      }else{
        readFileContents(ctx, pCur->zPath);
      }
    }
    case FSDIR_COLUMN_PATH:
    default: {
      /* The FSDIR_COLUMN_PATH and FSDIR_COLUMN_DIR are input parameters.
      ** always return their values as NULL */
      break;
    }
  }
  return SQLITE_OK;
}

/*
** Return the rowid for the current row. In this implementation, the
** first row returned is assigned rowid value 1, and each subsequent
................................................................................
static int fsdirEof(sqlite3_vtab_cursor *cur){
  fsdir_cursor *pCur = (fsdir_cursor*)cur;
  return (pCur->zPath==0);
}

/*
** xFilter callback.
**
** idxNum==1   PATH parameter only
** idxNum==2   Both PATH and DIR supplied
*/
static int fsdirFilter(
  sqlite3_vtab_cursor *cur, 
  int idxNum, const char *idxStr,
  int argc, sqlite3_value **argv
){
  const char *zDir = 0;
................................................................................
** that uses the generate_series virtual table.  This routine needs to create
** a query plan for each invocation and compute an estimated cost for that
** plan.
**
** In this implementation idxNum is used to represent the
** query plan.  idxStr is unused.
**
** The query plan is represented by values of idxNum:
**
**  (1)  The path value is supplied by argv[0]
**  (2)  Path is in argv[0] and dir is in argv[1]


*/
static int fsdirBestIndex(
  sqlite3_vtab *tab,
  sqlite3_index_info *pIdxInfo
){
  int i;                 /* Loop over constraints */
  int idxPath = -1;      /* Index in pIdxInfo->aConstraint of PATH= */
  int idxDir = -1;       /* Index in pIdxInfo->aConstraint of DIR= */
  int seenPath = 0;      /* True if an unusable PATH= constraint is seen */
  int seenDir = 0;       /* True if an unusable DIR= constraint is seen */
  const struct sqlite3_index_constraint *pConstraint;

  (void)tab;
  pConstraint = pIdxInfo->aConstraint;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){

    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    switch( pConstraint->iColumn ){
      case FSDIR_COLUMN_PATH: {
        if( pConstraint->usable ){
          idxPath = i;
          seenPath = 0;
        }else if( idxPath<0 ){
          seenPath = 1;
        }
        break;
      }
      case FSDIR_COLUMN_DIR: {
        if( pConstraint->usable ){
          idxDir = i;
          seenDir = 0;
        }else if( idxDir<0 ){
          seenDir = 1;
        }
        break;
      }
    } 
  }
  if( seenPath || seenDir ){
    /* If input parameters are unusable, disallow this plan */
    return SQLITE_CONSTRAINT;
  }

  if( idxPath<0 ){
    pIdxInfo->idxNum = 0;
    /* The pIdxInfo->estimatedCost should have been initialized to a huge
    ** number.  Leave it unchanged. */
    pIdxInfo->estimatedRows = 0x7fffffff;
  }else{
    pIdxInfo->aConstraintUsage[idxPath].omit = 1;
    pIdxInfo->aConstraintUsage[idxPath].argvIndex = 1;
    if( idxDir>=0 ){
      pIdxInfo->aConstraintUsage[idxDir].omit = 1;
      pIdxInfo->aConstraintUsage[idxDir].argvIndex = 2;
      pIdxInfo->idxNum = 2;
      pIdxInfo->estimatedCost = 10.0;
    }else{
      pIdxInfo->idxNum = 1;
      pIdxInfo->estimatedCost = 100.0;
    }
  }
................................................................................
** xBestIndex callback.
*/
static int zipfileBestIndex(
  sqlite3_vtab *tab,
  sqlite3_index_info *pIdxInfo
){
  int i;
  int idx = -1;
  int unusable = 0;

  for(i=0; i<pIdxInfo->nConstraint; i++){
    const struct sqlite3_index_constraint *pCons = &pIdxInfo->aConstraint[i];
    if( pCons->iColumn!=ZIPFILE_F_COLUMN_IDX ) continue;
    if( pCons->usable==0 ){
      unusable = 1;
    }else if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){


      idx = i;
    }
  }

  if( idx>=0 ){
    pIdxInfo->aConstraintUsage[idx].argvIndex = 1;
    pIdxInfo->aConstraintUsage[idx].omit = 1;
    pIdxInfo->estimatedCost = 1000.0;
    pIdxInfo->idxNum = 1;
  }else if( unusable ){

    return SQLITE_CONSTRAINT;
  }

  return SQLITE_OK;
}

static ZipfileEntry *zipfileNewEntry(const char *zPath){
  ZipfileEntry *pNew;
  pNew = sqlite3_malloc(sizeof(ZipfileEntry));
  if( pNew ){
................................................................................
      { "always",             SQLITE_TESTCTRL_ALWAYS,        "BOOLEAN"            },
      { "assert",             SQLITE_TESTCTRL_ASSERT,        "BOOLEAN"            },
    /*{ "benign_malloc_hooks",SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS, ""          },*/
    /*{ "bitvec_test",        SQLITE_TESTCTRL_BITVEC_TEST,   ""                },*/
      { "byteorder",          SQLITE_TESTCTRL_BYTEORDER,     ""                   },
    /*{ "fault_install",      SQLITE_TESTCTRL_FAULT_INSTALL, ""                }, */
      { "imposter",           SQLITE_TESTCTRL_IMPOSTER,   "SCHEMA ON/OFF ROOTPAGE"},
      { "internal_functions", SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, "BOOLEAN"       },
      { "localtime_fault",    SQLITE_TESTCTRL_LOCALTIME_FAULT,"BOOLEAN"           },
      { "never_corrupt",      SQLITE_TESTCTRL_NEVER_CORRUPT, "BOOLEAN"            },
      { "optimizations",      SQLITE_TESTCTRL_OPTIMIZATIONS, "DISABLE-MASK"       },
#ifdef YYCOVERAGE
      { "parser_coverage",    SQLITE_TESTCTRL_PARSER_COVERAGE, ""                 },
#endif
      { "pending_byte",       SQLITE_TESTCTRL_PENDING_BYTE,  "OFFSET  "           },
................................................................................
            isOk = 3;
          }
          break;

        /* sqlite3_test_control(int, int) */
        case SQLITE_TESTCTRL_ASSERT:
        case SQLITE_TESTCTRL_ALWAYS:
        case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS:
          if( nArg==3 ){
            int opt = booleanValue(azArg[2]);
            rc2 = sqlite3_test_control(testctrl, opt);
            isOk = 1;
          }
          break;

................................................................................
/*
** We need a default sqlite3_complete() implementation to use in case
** the shell is compiled with SQLITE_OMIT_COMPLETE.  The default assumes
** any arbitrary text is a complete SQL statement.  This is not very
** user-friendly, but it does seem to work.
*/
#ifdef SQLITE_OMIT_COMPLETE
#define sqlite3_complete(x) 1
#endif

/*
** Return true if zSql is a complete SQL statement.  Return false if it
** ends in the middle of a string literal or C-style comment.
*/
static int line_is_complete(char *zSql, int nSql){

**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
*/
#define SQLITE_VERSION        "3.26.0"
#define SQLITE_VERSION_NUMBER 3026000
#define SQLITE_SOURCE_ID      "2018-11-12 15:20:44 f9755f81b1c0fd29f242dce78a2fba570fa2714d76e93b8563f426a040352513"

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
................................................................................
#define SQLITE_TESTCTRL_PENDING_BYTE            11
#define SQLITE_TESTCTRL_ASSERT                  12
#define SQLITE_TESTCTRL_ALWAYS                  13
#define SQLITE_TESTCTRL_RESERVE                 14
#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
#define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */

#define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
#define SQLITE_TESTCTRL_EXPLAIN_STMT            19  /* NOT USED */
#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
#define SQLITE_TESTCTRL_NEVER_CORRUPT           20
#define SQLITE_TESTCTRL_VDBE_COVERAGE           21
#define SQLITE_TESTCTRL_BYTEORDER               22
#define SQLITE_TESTCTRL_ISINIT                  23
................................................................................

#ifndef SQLITE_OMIT_WAL
SQLITE_PRIVATE   int sqlite3PagerCheckpoint(Pager *pPager, sqlite3*, int, int*, int*);
SQLITE_PRIVATE   int sqlite3PagerWalSupported(Pager *pPager);
SQLITE_PRIVATE   int sqlite3PagerWalCallback(Pager *pPager);
SQLITE_PRIVATE   int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
SQLITE_PRIVATE   int sqlite3PagerCloseWal(Pager *pPager, sqlite3*);
# ifdef SQLITE_DIRECT_OVERFLOW_READ
SQLITE_PRIVATE   int sqlite3PagerUseWal(Pager *pPager, Pgno);
# endif
# ifdef SQLITE_ENABLE_SNAPSHOT
SQLITE_PRIVATE   int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot);
SQLITE_PRIVATE   int sqlite3PagerSnapshotOpen(Pager *pPager, sqlite3_snapshot *pSnapshot);
SQLITE_PRIVATE   int sqlite3PagerSnapshotRecover(Pager *pPager);
SQLITE_PRIVATE   int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot);
SQLITE_PRIVATE   void sqlite3PagerSnapshotUnlock(Pager *pPager);
# endif
#else
# define sqlite3PagerUseWal(x,y) 0



#endif

#ifdef SQLITE_ENABLE_ZIPVFS
SQLITE_PRIVATE   int sqlite3PagerWalFramesize(Pager *pPager);
#endif

/* Functions used to query pager state and configuration. */
................................................................................

/* Return the header size */
SQLITE_PRIVATE int sqlite3HeaderSizePcache(void);
SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void);

/* Number of dirty pages as a percentage of the configured cache size */
SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache*);





#endif /* _PCACHE_H_ */

/************** End of pcache.h **********************************************/
/************** Continuing where we left off in sqliteInt.h ******************/
/************** Include os.h in the middle of sqliteInt.h ********************/
/************** Begin file os.h **********************************************/
................................................................................
#define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
#define SQLITE_FUNC_MINMAX   0x1000 /* True for min() and max() aggregates */
#define SQLITE_FUNC_SLOCHNG  0x2000 /* "Slow Change". Value constant during a
                                    ** single query - might change over time */
#define SQLITE_FUNC_AFFINITY 0x4000 /* Built-in affinity() function */
#define SQLITE_FUNC_OFFSET   0x8000 /* Built-in sqlite_offset() function */
#define SQLITE_FUNC_WINDOW  0x10000 /* Built-in window-only function */
#define SQLITE_FUNC_WINDOW_SIZE  0x20000  /* Requires partition size as arg. */


/*
** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
** used to create the initializers for the FuncDef structures.
**
**   FUNCTION(zName, nArg, iArg, bNC, xFunc)
**     Used to create a scalar function definition of a function zName
................................................................................
   (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
#define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue) \
  {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \
   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,0,#zName, {0}}
#define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \
  {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \
   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xFinal,0,#zName, {0}}

#define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \
  {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \
   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}





/*
** All current savepoints are stored in a linked list starting at
** sqlite3.pSavepoint. The first element in the list is the most recently
** opened savepoint. Savepoints are added to the list by the vdbe
** OP_Savepoint instruction.
*/
................................................................................
  void (*xVdbeBranch)(void*,unsigned iSrcLine,u8 eThis,u8 eMx);  /* Callback */
  void *pVdbeBranchArg;                                     /* 1st argument */
#endif
#ifndef SQLITE_UNTESTABLE
  int (*xTestCallback)(int);        /* Invoked by sqlite3FaultSim() */
#endif
  int bLocaltimeFault;              /* True to fail localtime() calls */

  int iOnceResetThreshold;          /* When to reset OP_Once counters */
  u32 szSorterRef;                  /* Min size in bytes to use sorter-refs */
};

/*
** This macro is used inside of assert() statements to indicate that
** the assert is only valid on a well-formed database.  Instead of:
................................................................................
   0,                         /* xVdbeBranch */
   0,                         /* pVbeBranchArg */
#endif
#ifndef SQLITE_UNTESTABLE
   0,                         /* xTestCallback */
#endif
   0,                         /* bLocaltimeFault */

   0x7ffffffe,                /* iOnceResetThreshold */
   SQLITE_DEFAULT_SORTERREF_SIZE   /* szSorterRef */
};

/*
** Hash table for global functions - functions common to all
** database connections.  After initialization, this table is
................................................................................
SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3*, AuxData**, int, int);

int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(sqlite3*,VdbeCursor*,UnpackedRecord*,int*);
SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3*, BtCursor*, i64*);
SQLITE_PRIVATE int sqlite3VdbeExec(Vdbe*);

SQLITE_PRIVATE int sqlite3VdbeList(Vdbe*);

SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe*);
SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int);
SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*);
SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*);
SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*);
................................................................................
SQLITE_PRIVATE void sqlite3VdbeMemCast(Mem*,u8,u8);
SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,Mem*);
SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
#ifndef SQLITE_OMIT_WINDOWFUNC
SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem*, Mem*, FuncDef*);
#endif

SQLITE_PRIVATE const char *sqlite3OpcodeName(int);

SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int n);
SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int);
#ifdef SQLITE_DEBUG
SQLITE_PRIVATE int sqlite3VdbeFrameIsValid(VdbeFrame*);
#endif
SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void*);      /* Destructor on Mem */
................................................................................
  winceLock local;        /* Locks obtained by this instance of winFile */
  winceLock *shared;      /* Global shared lock memory for the file  */
#endif
#if SQLITE_MAX_MMAP_SIZE>0
  int nFetchOut;                /* Number of outstanding xFetch references */
  HANDLE hMap;                  /* Handle for accessing memory mapping */
  void *pMapRegion;             /* Area memory mapped */
  sqlite3_int64 mmapSize;       /* Usable size of mapped region */
  sqlite3_int64 mmapSizeActual; /* Actual size of mapped region */
  sqlite3_int64 mmapSizeMax;    /* Configured FCNTL_MMAP_SIZE value */
#endif
};

/*
** The winVfsAppData structure is used for the pAppData member for all of the
** Win32 VFS variants.
................................................................................
*/
static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
  winFile *pFile = (winFile*)id;  /* File handle object */
  int rc = SQLITE_OK;             /* Return code for this function */
  DWORD lastErrno;
#if SQLITE_MAX_MMAP_SIZE>0
  sqlite3_int64 oldMmapSize;




















#endif

  assert( pFile );
  SimulateIOError(return SQLITE_IOERR_TRUNCATE);
  OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, size=%lld, lock=%d\n",
           osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype));

................................................................................
/*
** Cleans up the mapped region of the specified file, if any.
*/
#if SQLITE_MAX_MMAP_SIZE>0
static int winUnmapfile(winFile *pFile){
  assert( pFile!=0 );
  OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, pMapRegion=%p, "
           "mmapSize=%lld, mmapSizeActual=%lld, mmapSizeMax=%lld\n",
           osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion,
           pFile->mmapSize, pFile->mmapSizeActual, pFile->mmapSizeMax));
  if( pFile->pMapRegion ){
    if( !osUnmapViewOfFile(pFile->pMapRegion) ){
      pFile->lastErrno = osGetLastError();
      OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, pMapRegion=%p, "
               "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), pFile,
               pFile->pMapRegion));
      return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
                         "winUnmapfile1", pFile->zPath);
    }
    pFile->pMapRegion = 0;
    pFile->mmapSize = 0;
    pFile->mmapSizeActual = 0;
  }
  if( pFile->hMap!=NULL ){
    if( !osCloseHandle(pFile->hMap) ){
      pFile->lastErrno = osGetLastError();
      OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, rc=SQLITE_IOERR_MMAP\n",
               osGetCurrentProcessId(), pFile, pFile->hMap));
      return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
................................................................................
      /* Log the error, but continue normal operation using xRead/xWrite */
      OSTRACE(("MAP-FILE-MAP pid=%lu, pFile=%p, rc=%s\n",
               osGetCurrentProcessId(), pFd, sqlite3ErrName(rc)));
      return SQLITE_OK;
    }
    pFd->pMapRegion = pNew;
    pFd->mmapSize = nMap;
    pFd->mmapSizeActual = nMap;
  }

  OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
           osGetCurrentProcessId(), pFd));
  return SQLITE_OK;
}
#endif /* SQLITE_MAX_MMAP_SIZE>0 */
................................................................................
  }
  pFile->lastErrno = NO_ERROR;
  pFile->zPath = zName;
#if SQLITE_MAX_MMAP_SIZE>0
  pFile->hMap = NULL;
  pFile->pMapRegion = 0;
  pFile->mmapSize = 0;
  pFile->mmapSizeActual = 0;
  pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap;
#endif

  OpenCounter(+1);
  return rc;
}

................................................................................
SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache *pCache){
  PgHdr *pDirty;
  int nDirty = 0;
  int nCache = numberOfCachePages(pCache);
  for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext) nDirty++;
  return nCache ? (int)(((i64)nDirty * 100) / nCache) : 0;
}










#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG)
/*
** For all dirty pages currently in the cache, invoke the specified
** callback. This is only used if the SQLITE_CHECK_PAGES macro is
** defined.
*/
................................................................................
  PgHdr1 *pNext;                 /* Next in hash table chain */
  PCache1 *pCache;               /* Cache that currently owns this page */
  PgHdr1 *pLruNext;              /* Next in LRU list of unpinned pages */
  PgHdr1 *pLruPrev;              /* Previous in LRU list of unpinned pages */
};

/*
** A page is pinned if it is no on the LRU list

*/
#define PAGE_IS_PINNED(p)    ((p)->pLruNext==0)
#define PAGE_IS_UNPINNED(p)  ((p)->pLruNext!=0)

/* Each page cache (or PCache) belongs to a PGroup.  A PGroup is a set 
** of one or more PCaches that are able to recycle each other's unpinned
** pages when they are under memory pressure.  A PGroup is an instance of
................................................................................
**
** instead of
**
**   if( pPager->jfd->pMethods ){ ...
*/
#define isOpen(pFd) ((pFd)->pMethods!=0)


/*
** Return true if this pager uses a write-ahead log to read page pgno.
** Return false if the pager reads pgno directly from the database.





*/
#if !defined(SQLITE_OMIT_WAL) && defined(SQLITE_DIRECT_OVERFLOW_READ)
SQLITE_PRIVATE int sqlite3PagerUseWal(Pager *pPager, Pgno pgno){




  u32 iRead = 0;
  int rc;
  if( pPager->pWal==0 ) return 0;
  rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);



  return rc || iRead;
}
#endif

#ifndef SQLITE_OMIT_WAL
# define pagerUseWal(x) ((x)->pWal!=0)
#else
# define pagerUseWal(x) 0
# define pagerRollbackWal(x) 0
# define pagerWalFrames(v,w,x,y) 0
# define pagerOpenWalIfPresent(z) SQLITE_OK
................................................................................
SQLITE_PRIVATE void sqlite3PagerSetCodec(
  Pager *pPager,
  void *(*xCodec)(void*,void*,Pgno,int),
  void (*xCodecSizeChng)(void*,int,int),
  void (*xCodecFree)(void*),
  void *pCodec
){
  pager_reset(pPager);
  if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);



  pPager->xCodec = pPager->memDb ? 0 : xCodec;
  pPager->xCodecSizeChng = xCodecSizeChng;
  pPager->xCodecFree = xCodecFree;
  pPager->pCodec = pCodec;
  setGetterMethod(pPager);
  pagerReportSize(pPager);
}
................................................................................
          rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
        }
        offset -= ovflSize;
      }else{
        /* Need to read this page properly. It contains some of the
        ** range of data that is being read (eOp==0) or written (eOp!=0).
        */
#ifdef SQLITE_DIRECT_OVERFLOW_READ
        sqlite3_file *fd;      /* File from which to do direct overflow read */
#endif
        int a = amt;
        if( a + offset > ovflSize ){
          a = ovflSize - offset;
        }

#ifdef SQLITE_DIRECT_OVERFLOW_READ
        /* If all the following are true:
        **
        **   1) this is a read operation, and 
        **   2) data is required from the start of this overflow page, and
        **   3) there is no open write-transaction, and
        **   4) the database is file-backed, and
        **   5) the page is not in the WAL file
        **   6) at least 4 bytes have already been read into the output buffer 
        **
        ** then data can be read directly from the database file into the
        ** output buffer, bypassing the page-cache altogether. This speeds
        ** up loading large records that span many overflow pages.
        */
        if( eOp==0                                             /* (1) */
         && offset==0                                          /* (2) */
         && pBt->inTransaction==TRANS_READ                     /* (3) */
         && (fd = sqlite3PagerFile(pBt->pPager))->pMethods     /* (4) */
         && 0==sqlite3PagerUseWal(pBt->pPager, nextPage)       /* (5) */
         && &pBuf[-4]>=pBufStart                               /* (6) */
        ){

          u8 aSave[4];
          u8 *aWrite = &pBuf[-4];
          assert( aWrite>=pBufStart );                         /* due to (6) */
          memcpy(aSave, aWrite, 4);
          rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));
          nextPage = get4byte(aWrite);
          memcpy(aWrite, aSave, 4);
................................................................................
        if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){
          /* Date/time functions that use 'now', and other functions like
          ** sqlite_version() that might change over time cannot be used
          ** in an index. */
          notValid(pParse, pNC, "non-deterministic functions",
                   NC_IdxExpr|NC_PartIdx);
        }









      }

      if( 0==IN_RENAME_OBJECT ){
#ifndef SQLITE_OMIT_WINDOWFUNC
        assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
          || (pDef->xValue==0 && pDef->xInverse==0)
          || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
................................................................................
  }
}
#else
# define renameTokenCheckAll(x,y)
#endif

/*
** Add a new RenameToken object mapping parse tree element pPtr into
** token *pToken to the Parse object currently under construction.
**
** Return a copy of pPtr.






*/
SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse *pParse, void *pPtr, Token *pToken){
  RenameToken *pNew;
  assert( pPtr || pParse->db->mallocFailed );
  renameTokenCheckAll(pParse, pPtr);
  pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
  if( pNew ){
................................................................................
**   8. bTemp:    True if zSql comes from temp schema
**
** Do a column rename operation on the CREATE statement given in zSql.
** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
** into zNew.  The name should be quoted if bQuote is true.
**
** This function is used internally by the ALTER TABLE RENAME COLUMN command.
** Though accessible to application code, it is not intended for use by
** applications.  The existance of this function, and the way it works,
** is subject to change without notice.
**
** If any of the parameters are out-of-bounds, then simply return NULL.
** An out-of-bounds parameter can only occur when the application calls
** this function directly.  The parameters will always be well-formed when
** this routine is invoked by the bytecode for a legitimate ALTER TABLE
** statement.
*/
static void renameColumnFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  sqlite3 *db = sqlite3_context_db_handle(context);
................................................................................
}

/*
** Register built-in functions used to help implement ALTER TABLE
*/
SQLITE_PRIVATE void sqlite3AlterFunctions(void){
  static FuncDef aAlterTableFuncs[] = {
    FUNCTION(sqlite_rename_column,  9, 0, 0, renameColumnFunc),
    FUNCTION(sqlite_rename_table,  7, 0, 0, renameTableFunc),
    FUNCTION(sqlite_rename_test,  5, 0, 0, renameTableTest),
  };
  sqlite3InsertBuiltinFuncs(aAlterTableFuncs, ArraySize(aAlterTableFuncs));
}
#endif  /* SQLITE_ALTER_TABLE */

/************** End of alter.c ***********************************************/
/************** Begin file analyze.c *****************************************/
................................................................................
    ** reopen it as a MemDB */
    pVfs = sqlite3_vfs_find("memdb");
    if( pVfs==0 ) return;
    pNew = &db->aDb[db->init.iDb];
    if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt);
    pNew->pBt = 0;
    pNew->pSchema = 0;
    rc = sqlite3BtreeOpen(pVfs, "x", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);
  }else{
    /* This is a real ATTACH
    **
    ** Check for the following errors:
    **
    **     * Too many attached databases,
    **     * Transaction currently open
................................................................................
/*
** Erase all schema information from all attached databases (including
** "main" and "temp") for a single database connection.
*/
SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
  int i;
  sqlite3BtreeEnterAll(db);
  assert( db->nSchemaLock==0 );
  for(i=0; i<db->nDb; i++){
    Db *pDb = &db->aDb[i];
    if( pDb->pSchema ){

      sqlite3SchemaClear(pDb->pSchema);



    }
  }
  db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
  sqlite3VtabUnlockList(db);
  sqlite3BtreeLeaveAll(db);

  sqlite3CollapseDatabaseArray(db);

}

/*
** This routine is called when a commit occurs.
*/
SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){
  db->mDbFlags &= ~DBFLAG_SchemaChange;
................................................................................
    assert( pTab->nCol==j );
  }else{
    pPk->nColumn = pTab->nCol;
  }
  recomputeColumnsNotIndexed(pPk);
}


/*
** Return true if zName is a shadow table name in the current database
** connection.
**
** zName is temporarily modified while this routine is running, but is
** restored to its original value prior to this routine returning.
*/
................................................................................
  if( !IsVirtual(pTab) ) return 0;
  pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->azModuleArg[0]);
  if( pMod==0 ) return 0;
  if( pMod->pModule->iVersion<3 ) return 0;
  if( pMod->pModule->xShadowName==0 ) return 0;
  return pMod->pModule->xShadowName(zTail+1);
}




/*
** This routine is called to report the final ")" that terminates
** a CREATE TABLE statement.
**
** The table structure that other action routines have been building
** is added to the internal hash tables, assuming no errors have
................................................................................
  }
  if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0;
  db = pParse->db;
  if( (pTab->tabFlags & TF_Readonly)!=0 ){
    return sqlite3WritableSchema(db)==0 && pParse->nested==0;
  }
  assert( pTab->tabFlags & TF_Shadow );
  return (db->flags & SQLITE_Defensive)!=0
           && db->nVdbeExec==0
           && db->pVtabCtx==0;


}

/*
** Check to make sure the given table is writable.  If it is not
** writable, generate an error message and return 1.  If it is
** writable return 0;
*/
................................................................................

#ifdef SQLITE_OMIT_VIRTUALTABLE
# define sqlite3_create_module 0
# define sqlite3_create_module_v2 0
# define sqlite3_declare_vtab 0
# define sqlite3_vtab_config 0
# define sqlite3_vtab_on_conflict 0

#endif

#ifdef SQLITE_OMIT_SHARED_CACHE
# define sqlite3_enable_shared_cache 0
#endif

#if defined(SQLITE_OMIT_TRACE) || defined(SQLITE_OMIT_DEPRECATED)
................................................................................
  ** dflt_value: The default value for the column, if any.
  ** pk:         Non-zero for PK fields.
  */
  case PragTyp_TABLE_INFO: if( zRight ){
    Table *pTab;
    pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
    if( pTab ){

      int i, k;
      int nHidden = 0;
      Column *pCol;
      Index *pPk = sqlite3PrimaryKeyIndex(pTab);
      pParse->nMem = 7;
      sqlite3CodeVerifySchema(pParse, iDb);
      sqlite3ViewGetColumnNames(pParse, pTab);
      for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
        int isHidden = IsHiddenColumn(pCol);
        if( isHidden && pPragma->iArg==0 ){
          nHidden++;
          continue;
        }
................................................................................
#endif

  case PragTyp_INDEX_INFO: if( zRight ){
    Index *pIdx;
    Table *pTab;
    pIdx = sqlite3FindIndex(db, zRight, zDb);
    if( pIdx ){

      int i;
      int mx;
      if( pPragma->iArg ){
        /* PRAGMA index_xinfo (newer version with more rows and columns) */
        mx = pIdx->nColumn;
        pParse->nMem = 6;
      }else{
        /* PRAGMA index_info (legacy version) */
        mx = pIdx->nKeyCol;
        pParse->nMem = 3;
      }
      pTab = pIdx->pTable;
      sqlite3CodeVerifySchema(pParse, iDb);
      assert( pParse->nMem<=pPragma->nPragCName );
      for(i=0; i<mx; i++){
        i16 cnum = pIdx->aiColumn[i];
        sqlite3VdbeMultiLoad(v, 1, "iisX", i, cnum,
                             cnum<0 ? 0 : pTab->aCol[cnum].zName);
        if( pPragma->iArg ){
          sqlite3VdbeMultiLoad(v, 4, "isiX",
................................................................................

  case PragTyp_INDEX_LIST: if( zRight ){
    Index *pIdx;
    Table *pTab;
    int i;
    pTab = sqlite3FindTable(db, zRight, zDb);
    if( pTab ){

      pParse->nMem = 5;
      sqlite3CodeVerifySchema(pParse, iDb);
      for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
        const char *azOrigin[] = { "c", "u", "pk" };
        sqlite3VdbeMultiLoad(v, 1, "isisi",
           i,
           pIdx->zName,
           IsUniqueIndex(pIdx),
           azOrigin[pIdx->idxType],
................................................................................
  case PragTyp_FUNCTION_LIST: {
    int i;
    HashElem *j;
    FuncDef *p;
    pParse->nMem = 2;
    for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
      for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash ){

        sqlite3VdbeMultiLoad(v, 1, "si", p->zName, 1);
      }
    }
    for(j=sqliteHashFirst(&db->aFunc); j; j=sqliteHashNext(j)){
      p = (FuncDef*)sqliteHashData(j);
      sqlite3VdbeMultiLoad(v, 1, "si", p->zName, 0);
    }
................................................................................
  case PragTyp_FOREIGN_KEY_LIST: if( zRight ){
    FKey *pFK;
    Table *pTab;
    pTab = sqlite3FindTable(db, zRight, zDb);
    if( pTab ){
      pFK = pTab->pFKey;
      if( pFK ){

        int i = 0; 
        pParse->nMem = 8;
        sqlite3CodeVerifySchema(pParse, iDb);
        while(pFK){
          int j;
          for(j=0; j<pFK->nCol; j++){
            sqlite3VdbeMultiLoad(v, 1, "iissssss",
                   i,
                   j,
                   pFK->zTo,
................................................................................
    int addrOk;            /* Jump here if the key is OK */
    int *aiCols;           /* child to parent column mapping */

    regResult = pParse->nMem+1;
    pParse->nMem += 4;
    regKey = ++pParse->nMem;
    regRow = ++pParse->nMem;
    sqlite3CodeVerifySchema(pParse, iDb);
    k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
    while( k ){

      if( zRight ){
        pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
        k = 0;
      }else{
        pTab = (Table*)sqliteHashData(k);
        k = sqliteHashNext(k);
      }
      if( pTab==0 || pTab->pFKey==0 ) continue;


      sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
      if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
      sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
      sqlite3VdbeLoadString(v, regResult, pTab->zName);
      for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
        pParent = sqlite3FindTable(db, pFK->zTo, zDb);
        if( pParent==0 ) continue;
        pIdx = 0;
        sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
        x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0);
        if( x==0 ){
          if( pIdx==0 ){
            sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
          }else{
            sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
            sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
          }
        }else{
          k = 0;
          break;
        }
      }
................................................................................

/*
** The table object reference passed as the second argument to this function
** must represent a virtual table. This function invokes the xBestIndex()
** method of the virtual table with the sqlite3_index_info object that
** comes in as the 3rd argument to this function.
**
** If an error occurs, pParse is populated with an error message and a
** non-zero value is returned. Otherwise, 0 is returned and the output
** part of the sqlite3_index_info structure is left populated.


**
** Whether or not an error is returned, it is the responsibility of the
** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates
** that this is required.
*/
static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
  sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
  int rc;

  TRACE_IDX_INPUTS(p);
  rc = pVtab->pModule->xBestIndex(pVtab, p);
  TRACE_IDX_OUTPUTS(p);

  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_NOMEM ){
      sqlite3OomFault(pParse->db);
    }else if( !pVtab->zErrMsg ){
      sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
    }else{
      sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
    }
  }
  sqlite3_free(pVtab->zErrMsg);
  pVtab->zErrMsg = 0;

#if 0
  /* This error is now caught by the caller.
  ** Search for "xBestIndex malfunction" below */
  for(i=0; i<p->nConstraint; i++){
    if( !p->aConstraint[i].usable && p->aConstraintUsage[i].argvIndex>0 ){
      sqlite3ErrorMsg(pParse, 
          "table %s: xBestIndex returned an invalid plan", pTab->zName);
    }
  }
#endif

  return pParse->nErr;
}
#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */

#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
/*
** Estimate the location of a particular key among all keys in an
** index.  Store the results in aStat as follows:
................................................................................
  pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2;
  pIdxInfo->estimatedRows = 25;
  pIdxInfo->idxFlags = 0;
  pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed;

  /* Invoke the virtual table xBestIndex() method */
  rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);









  if( rc ) return rc;


  mxTerm = -1;
  assert( pNew->nLSlot>=nConstraint );
  for(i=0; i<nConstraint; i++) pNew->aLTerm[i] = 0;
  pNew->u.vtab.omitMask = 0;
  pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
  for(i=0; i<nConstraint; i++, pIdxCons++){
................................................................................
** of this template is copied straight through into the generate parser
** source file.
**
** The following is the concatenation of all %include directives from the
** input grammar file:
*/
/* #include <stdio.h> */

/************ Begin %include sections from the grammar ************************/

/* #include "sqliteInt.h" */

/*
** Disable all error recovery processing in the parser push-down
** automaton.
................................................................................
#define sqlite3ParserARG_STORE
#define sqlite3ParserCTX_SDECL Parse *pParse;
#define sqlite3ParserCTX_PDECL ,Parse *pParse
#define sqlite3ParserCTX_PARAM ,pParse
#define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
#define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
#define YYFALLBACK 1
#define YYNSTATE             525
#define YYNRULE              367
#define YYNTOKEN             155
#define YY_MAX_SHIFT         524
#define YY_MIN_SHIFTREDUCE   760
#define YY_MAX_SHIFTREDUCE   1126
#define YY_ERROR_ACTION      1127
#define YY_ACCEPT_ACTION     1128
#define YY_NO_ACTION         1129
#define YY_MIN_REDUCE        1130
#define YY_MAX_REDUCE        1496
/************* End control #defines *******************************************/
#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

/* Define the yytestcase() macro to be a no-op if is not already defined
** otherwise.
**
** Applications can choose to define yytestcase() in the %include section
................................................................................
**  yy_reduce_ofst[]   For each state, the offset into yy_action for
**                     shifting non-terminals after a reduce.
**  yy_default[]       Default action for each state.
**
*********** Begin parsing tables **********************************************/
#define YY_ACTTAB_COUNT (2009)
static const YYACTIONTYPE yy_action[] = {
 /*     0 */   372,  105,  102,  197,  105,  102,  197,  519, 1128,    1,
 /*    10 */     1,  524,    2, 1132,  519, 1196, 1175, 1460,  275,  374,
 /*    20 */   127, 1393, 1201, 1201, 1196, 1170,  178, 1209,   64,   64,
 /*    30 */   481,  891,  326,  432,  352,   37,   37,  812,  366,  892,
 /*    40 */   513,  513,  513,  112,  113,  103, 1104, 1104,  957,  960,
 /*    50 */   950,  950,  110,  110,  111,  111,  111,  111,  369,  252,
 /*    60 */   252,  519,  252,  252,  501,  519,  313,  519,  463,  519,
 /*    70 */  1083,  495,  516,  482,    6,  516,  813,  134,  502,  228,
 /*    80 */   194,  432,   37,   37,  519,  208,   64,   64,   64,   64,
 /*    90 */    13,   13,  109,  109,  109,  109,  108,  108,  107,  107,
 /*   100 */   107,  106,  405,  258,  385,   13,   13,  402,  401,  432,
 /*   110 */   252,  252,  374,  480,  409, 1108, 1083, 1084, 1085,  390,
 /*   120 */  1110,  394,  501,  516,  501, 1427, 1423,  308, 1109,  311,
 /*   130 */  1260,  500,  374,  503,   16,   16,  112,  113,  103, 1104,
 /*   140 */  1104,  957,  960,  950,  950,  110,  110,  111,  111,  111,
 /*   150 */   111,  262, 1111,  499, 1111,  405,  112,  113,  103, 1104,
 /*   160 */  1104,  957,  960,  950,  950,  110,  110,  111,  111,  111,
 /*   170 */   111,  129, 1429,  347, 1424,  343, 1063,  496, 1061,  263,
 /*   180 */    73,  105,  102,  197,  998,  109,  109,  109,  109,  108,
 /*   190 */   108,  107,  107,  107,  106,  405,  374,  111,  111,  111,
 /*   200 */   111,  104,  496,   89, 1436,  109,  109,  109,  109,  108,
 /*   210 */   108,  107,  107,  107,  106,  405,  111,  111,  111,  111,
 /*   220 */   112,  113,  103, 1104, 1104,  957,  960,  950,  950,  110,
 /*   230 */   110,  111,  111,  111,  111,  109,  109,  109,  109,  108,
 /*   240 */   108,  107,  107,  107,  106,  405,  114,  108,  108,  107,
 /*   250 */   107,  107,  106,  405,  109,  109,  109,  109,  108,  108,
 /*   260 */   107,  107,  107,  106,  405,  152,  403,  403,  403,  109,
 /*   270 */   109,  109,  109,  108,  108,  107,  107,  107,  106,  405,
 /*   280 */   178,  497, 1416,  438, 1041, 1490, 1083,  519, 1490,  374,
 /*   290 */   425,  301,  361,  416,   74, 1083,  109,  109,  109,  109,
 /*   300 */   108,  108,  107,  107,  107,  106,  405, 1417,   37,   37,
 /*   310 */  1435,  274,  510,  112,  113,  103, 1104, 1104,  957,  960,
 /*   320 */   950,  950,  110,  110,  111,  111,  111,  111, 1440,  524,
 /*   330 */     2, 1132, 1083, 1084, 1085,  434,  275, 1083,  127,  370,
 /*   340 */   937, 1083, 1084, 1085,  220, 1209,  917,  462,  459,  458,
 /*   350 */   396,  167,  519, 1039,  152,  449,  928,  457,  152,  878,
 /*   360 */   927,  293,  109,  109,  109,  109,  108,  108,  107,  107,
 /*   370 */   107,  106,  405,   13,   13,  261,  857,  252,  252,  227,
 /*   380 */   106,  405,  374, 1083, 1084, 1085,  315,  392, 1083,  300,
 /*   390 */   516,  927,  927,  929,  231,  327, 1259, 1392, 1427,  494,
 /*   400 */   274,  510,   12,  208,  274,  510,  112,  113,  103, 1104,
 /*   410 */  1104,  957,  960,  950,  950,  110,  110,  111,  111,  111,
 /*   420 */   111, 1444,  290, 1132,  292, 1083, 1101,  247,  275, 1102,
 /*   430 */   127,  391,  409,  393, 1083, 1084, 1085, 1209,  159,  238,
 /*   440 */   255,  325,  465,  320,  464,  225,  794,  105,  102,  197,
 /*   450 */   517,  318,  846,  846,  449,  109,  109,  109,  109,  108,
 /*   460 */   108,  107,  107,  107,  106,  405,  519,  518,  519,  252,
 /*   470 */   252, 1083, 1084, 1085,  439,  374, 1102,  937, 1464,  798,
 /*   480 */   274,  510,  516,  105,  102,  197,  340,   63,   63,   64,
 /*   490 */    64,   27,  794,  928,  291,  208, 1358,  927,  519,  112,
 /*   500 */   113,  103, 1104, 1104,  957,  960,  950,  950,  110,  110,
 /*   510 */   111,  111,  111,  111,  107,  107,  107,  106,  405,   49,
 /*   520 */    49,  519,   28, 1083,  409,  501,  425,  301,  927,  927,
 /*   530 */   929,  186,  472, 1083,  471, 1003, 1003,  446,  519, 1083,
 /*   540 */   338,  519,   45,   45, 1087,  346,  173,  168,  109,  109,
 /*   550 */   109,  109,  108,  108,  107,  107,  107,  106,  405,   13,
 /*   560 */    13,  205,   13,   13,  252,  252, 1199, 1199,  374, 1083,
 /*   570 */  1084, 1085,  791,  265,    5,  363,  498,  516,  473, 1083,
 /*   580 */  1084, 1085,  402,  401, 1083, 1083, 1084, 1085,    3,  282,
 /*   590 */  1083, 1087,  112,  113,  103, 1104, 1104,  957,  960,  950,
 /*   600 */   950,  110,  110,  111,  111,  111,  111,  252,  252, 1019,
 /*   610 */   220, 1083,  877,  462,  459,  458,  947,  947,  958,  961,
 /*   620 */   516,  252,  252,  457, 1020, 1083,  449, 1111, 1213, 1111,
 /*   630 */  1083, 1084, 1085,  519,  516,  430, 1083, 1084, 1085, 1021,
 /*   640 */   516,  109,  109,  109,  109,  108,  108,  107,  107,  107,
 /*   650 */   106,  405, 1056,  519,   50,   50,  519, 1083, 1084, 1085,
 /*   660 */   832,  374, 1055,  383,  415, 1068, 1362,  207,  412,  777,
 /*   670 */   833, 1083, 1084, 1085,   64,   64,  326,   64,   64, 1306,
 /*   680 */   951,  415,  414, 1362, 1364,  112,  113,  103, 1104, 1104,
 /*   690 */   957,  960,  950,  950,  110,  110,  111,  111,  111,  111,
 /*   700 */   298,  486,  519, 1041, 1491,  519,  438, 1491,  358, 1124,
 /*   710 */   487, 1000,  917,  489,  470, 1000,  132,  178,   33,  454,
 /*   720 */  1207,  136,  410,   64,   64,  483,   64,   64,  423,  373,
 /*   730 */   283, 1150,  252,  252,  109,  109,  109,  109,  108,  108,
 /*   740 */   107,  107,  107,  106,  405,  516,  224,  444,  415,  266,
 /*   750 */  1362,  266,  252,  252,  374,  300,  420,  286,  938,  400,
 /*   760 */   980,  474,  404,  252,  252,  516,    9,  477,  231,  504,
 /*   770 */   358, 1040, 1039, 1492,  359,  378,  516, 1125,  112,  113,
 /*   780 */   103, 1104, 1104,  957,  960,  950,  950,  110,  110,  111,
 /*   790 */   111,  111,  111,  252,  252, 1019,  519, 1351,  299,  252,
 /*   800 */   252,  252,  252, 1102,  379,  249,  516,  449,  876,  326,
 /*   810 */  1020,  484,  516,  195,  516,  438,  273,   15,   15,  519,
 /*   820 */   318,  519,   95,  519,   93, 1021,  371,  109,  109,  109,
 /*   830 */   109,  108,  108,  107,  107,  107,  106,  405,  519, 1125,
 /*   840 */    39,   39,   51,   51,   52,   52,  507,  374,  519, 1208,
 /*   850 */  1102,  922,  443,  345,  133,  440,  223,  222,  221,   53,
 /*   860 */    53,  326, 1404,  765,  766,  767,  519,  374,   88,   54,
 /*   870 */    54,  112,  113,  103, 1104, 1104,  957,  960,  950,  950,
 /*   880 */   110,  110,  111,  111,  111,  111,  411,   55,   55,  196,
 /*   890 */   519,  112,  113,  103, 1104, 1104,  957,  960,  950,  950,
 /*   900 */   110,  110,  111,  111,  111,  111,  135,  264, 1153,  380,
 /*   910 */   519,   40,   40,  519,  876,  519,  997,  519,  997,  116,
 /*   920 */   109,  109,  109,  109,  108,  108,  107,  107,  107,  106,
 /*   930 */   405,   41,   41,  519,   43,   43,   44,   44,   56,   56,
 /*   940 */   109,  109,  109,  109,  108,  108,  107,  107,  107,  106,
 /*   950 */   405,  519,  383,  519,   57,   57,  519,  803,  519,  383,
 /*   960 */   519,  449,  200,  519,  327,  519, 1401,  519, 1463,  519,
 /*   970 */  1291,  821,   58,   58,   14,   14,  519,   59,   59,  118,
 /*   980 */   118,   60,   60,  519,   46,   46,   61,   61,   62,   62,
 /*   990 */    47,   47,  519,  190,  189,   91,  519,  140,  140,  519,
 /*  1000 */   398,  519,  277, 1204,  141,  141,  519, 1119,  519,  996,
 /*  1010 */   519,  996,  519,   69,   69,  374,  278,   48,   48,  259,
 /*  1020 */    65,   65,  119,  119,  246,  246,  260,   66,   66,  120,
 /*  1030 */   120,  121,  121,  117,  117,  374,  519,  516,  387,  112,
 /*  1040 */   113,  103, 1104, 1104,  957,  960,  950,  950,  110,  110,
 /*  1050 */   111,  111,  111,  111,  519,  876,  519,  139,  139,  112,
 /*  1060 */   113,  103, 1104, 1104,  957,  960,  950,  950,  110,  110,
 /*  1070 */   111,  111,  111,  111, 1291,  138,  138,  125,  125,  519,
 /*  1080 */    12,  519,  281, 1291,  519,  449,  131, 1291,  109,  109,
 /*  1090 */   109,  109,  108,  108,  107,  107,  107,  106,  405,  519,
 /*  1100 */   124,  124,  122,  122,  519,  123,  123,  519,  109,  109,
 /*  1110 */   109,  109,  108,  108,  107,  107,  107,  106,  405,  519,
 /*  1120 */    68,   68,  467,  787,  519,   70,   70,  306,   67,   67,
 /*  1130 */  1036,  253,  253,  360, 1291,  191,  196, 1437,  469, 1305,
 /*  1140 */    38,   38,  388,   94,  516,   42,   42,  177,  852,  274,
 /*  1150 */   510,  389,  424,  851, 1360,  445,  512,  380,  381,  153,
 /*  1160 */   427,  876,  436,  374,  224,  251,  194,  891,  182,  297,
 /*  1170 */   787,  852,   88,  254,  470,  892,  851,  919,  811,  810,
 /*  1180 */   230, 1245,  914,  374,   17,  417,  801,  112,  113,  103,
 /*  1190 */  1104, 1104,  957,  960,  950,  950,  110,  110,  111,  111,
 /*  1200 */   111,  111,  399,  818,  819, 1179,  987,  112,  101,  103,
 /*  1210 */  1104, 1104,  957,  960,  950,  950,  110,  110,  111,  111,
 /*  1220 */   111,  111,  379,  426,  431,  433,  302,  230,  230,   88,
 /*  1230 */  1244,  455,  316,  801,  226,   88,  109,  109,  109,  109,
 /*  1240 */   108,  108,  107,  107,  107,  106,  405,   86,  437,  983,
 /*  1250 */   931,  885,  226,  987,  230,  419,  109,  109,  109,  109,
 /*  1260 */   108,  108,  107,  107,  107,  106,  405,  324,  849,  785,
 /*  1270 */   850,  100,  130,  100, 1407,  294,  374,  323, 1381, 1380,
 /*  1280 */   441, 1453,  303, 1241,  307,  310,  312,  314, 1192, 1178,
 /*  1290 */  1177, 1176,  319,  328,  329, 1232,  374,  931, 1253,  271,
 /*  1300 */  1290,  113,  103, 1104, 1104,  957,  960,  950,  950,  110,
 /*  1310 */   110,  111,  111,  111,  111, 1228, 1239,  506,  505, 1296,
 /*  1320 */  1225, 1159,  103, 1104, 1104,  957,  960,  950,  950,  110,
 /*  1330 */   110,  111,  111,  111,  111, 1152, 1141, 1140, 1142, 1447,
 /*  1340 */   450,  244,  184,   98,  511,  188,    4,  357,  331,  109,
 /*  1350 */   109,  109,  109,  108,  108,  107,  107,  107,  106,  405,
 /*  1360 */   514,  333,  335,  199,  418,  460,  296,  289,  322,  109,
 /*  1370 */   109,  109,  109,  108,  108,  107,  107,  107,  106,  405,
 /*  1380 */    11,  285, 1283,  406,  365,  192, 1175, 1355,  435,  509,
 /*  1390 */   350, 1354,  337,   98,  511,  508,    4,  187, 1450, 1119,
 /*  1400 */   233, 1400,  155, 1398, 1116,  152,   72,   75,  382,  429,
 /*  1410 */   514,  165,  115,  499,  937, 1280, 1275,   30,  149,  157,
 /*  1420 */    96,   96,    8,  284,   86,  288,  287,   97, 1272,  406,
 /*  1430 */   521,  520,  421,  406,  927,  422,  453,  210,  160,  161,
 /*  1440 */   162,  163,  362,  428, 1286,  508,  442,  214,   80,  364,
 /*  1450 */    31,  274,  510,  169, 1349,  448,  492,  245, 1369,  216,
 /*  1460 */   174,  491,  451,  309,  937,  927,  927,  929,  930,   24,
 /*  1470 */    96,   96,  305,  217,  367,  466, 1143,   97,  218,  406,
 /*  1480 */   521,  520, 1195, 1194,  927, 1193,  395,  803,   98,  511,
 /*  1490 */   368,    4, 1186, 1167, 1185,  269, 1166,  321, 1165, 1462,
 /*  1500 */   397,  270,  485,  476,  479,  514,   85,  232, 1236,   98,
 /*  1510 */   511,  330,    4,  490,  340,  927,  927,  929,  930,   24,
 /*  1520 */  1439, 1072,  408, 1237,  339,  256,  514, 1418,  406,   10,
 /*  1530 */   356,  356,  355,  241,  353,  181,   92,  774, 1235, 1218,
 /*  1540 */   508,  342,   87,  332,  334, 1217, 1234,  336,  344,  406,
 /*  1550 */   201,  492,  280,  183,  488,  348,  493,  349,  239,  937,
 /*  1560 */   279,  508, 1335,   29, 1149,   96,   96,  522, 1078,  272,
 /*  1570 */   243,  240,   97,  242,  406,  521,  520,  523, 1138,  927,
 /*  1580 */   937,  142, 1133, 1385,  143, 1386,   96,   96,  856,  376,
 /*  1590 */   203,  761,  154,   97, 1384,  406,  521,  520,  204,  377,
 /*  1600 */   927,  146,  144, 1383,  407, 1163, 1162,  128,  202,   71,
 /*  1610 */   927,  927,  929,  930,   24,  267, 1160,  185,  276,  198,
 /*  1620 */   257,   98,  511,  126,    4,  911,  995,  156,  993,  145,
 /*  1630 */   206,  927,  927,  929,  930,   24,  158,  835,  514,  209,
 /*  1640 */   295, 1009,  375,  164,  915,  147,  384,  274,  510,  386,
 /*  1650 */   166,   76,   77,   78,  148, 1012,  211,  212, 1008,  137,
 /*  1660 */    18,  406,   79,  213,  304, 1001, 1113,  230,  447,  215,
 /*  1670 */   413,  171,   32,  508,  323,  776,  170,  452,  172,  219,
 /*  1680 */   456,   81,   19,   20,  492,  317,  461,   82,  268,  491,
 /*  1690 */   150,  814,  937,  179,   83,  468,  151,  180,   96,   96,
 /*  1700 */   963,   84, 1044,   34,  475,   97, 1045,  406,  521,  520,
 /*  1710 */  1072,  408,  927,   35,  256,  884,  478,  248,  193,  356,
 /*  1720 */   356,  355,  241,  353,  250,  175,  774,  229,  879,   21,
 /*  1730 */   100,   98,  511,   22,    4, 1058, 1049,  176,  341,  201,
 /*  1740 */     7,  280, 1062,  927,  927,  929,  930,   24,  514,  279,
 /*  1750 */    88, 1060,   23,  978,  964,  962,  966, 1018, 1017,  967,
 /*  1760 */   235,   90,  511,  234,    4,   25,   36,  515,  932,  786,
 /*  1770 */   845,  406,   99,   26,  236,  237,  351, 1455,  514,  203,
 /*  1780 */   354, 1454, 1073,  508, 1129, 1129, 1129,  204, 1129, 1129,
 /*  1790 */   146, 1129, 1129, 1129, 1129, 1129, 1129,  202, 1129, 1129,
 /*  1800 */  1129,  406,  937, 1129, 1129, 1129, 1129, 1129,   96,   96,
 /*  1810 */  1129, 1129, 1129,  508, 1129,   97, 1129,  406,  521,  520,
 /*  1820 */  1129, 1129,  927, 1129, 1129, 1129, 1129, 1129, 1129, 1129,
 /*  1830 */  1129,  375,  937, 1129, 1129, 1129,  274,  510,   96,   96,
 /*  1840 */  1129, 1129, 1129, 1129, 1129,   97, 1129,  406,  521,  520,
 /*  1850 */  1129, 1129,  927,  927,  927,  929,  930,   24, 1129,  413,
 /*  1860 */  1129, 1129, 1129,  256, 1129, 1129, 1129, 1129,  356,  356,
 /*  1870 */   355,  241,  353, 1129, 1129,  774, 1129, 1129, 1129, 1129,
 /*  1880 */  1129, 1129, 1129,  927,  927,  929,  930,   24,  201, 1129,
 /*  1890 */   280, 1129, 1129, 1129, 1129, 1129, 1129, 1129,  279, 1129,
 /*  1900 */  1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,
 /*  1910 */  1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,
 /*  1920 */  1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,  203, 1129,
 /*  1930 */  1129, 1129, 1129, 1129, 1129, 1129,  204, 1129, 1129,  146,
 /*  1940 */  1129, 1129, 1129, 1129, 1129, 1129,  202, 1129, 1129, 1129,
 /*  1950 */  1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,
 /*  1960 */  1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,
 /*  1970 */  1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,
 /*  1980 */   375, 1129, 1129, 1129, 1129,  274,  510, 1129, 1129, 1129,
 /*  1990 */  1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,
 /*  2000 */  1129, 1129, 1129, 1129, 1129, 1129, 1129, 1129,  413,
};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */   184,  238,  239,  240,  238,  239,  240,  163,  155,  156,
 /*    10 */   157,  158,  159,  160,  163,  191,  192,  183,  165,   19,
 /*    20 */   167,  258,  202,  203,  200,  191,  163,  174,  184,  185,
 /*    30 */   174,   31,  163,  163,  171,  184,  185,   35,  175,   39,
 /*    40 */   179,  180,  181,   43,   44,   45,   46,   47,   48,   49,
................................................................................
 /*  1340 */   251,  250,  209,   19,   20,  182,   22,  161,  222,   92,
 /*  1350 */    93,   94,   95,   96,   97,   98,   99,  100,  101,  102,
 /*  1360 */    36,  222,  222,  260,  226,  188,  256,  226,  187,   92,
 /*  1370 */    93,   94,   95,   96,   97,   98,   99,  100,  101,  102,
 /*  1380 */   210,  213,  213,   59,  213,  196,  192,  187,  256,  244,
 /*  1390 */   212,  187,  226,   19,   20,   71,   22,  210,  166,   60,
 /*  1400 */   130,  170,  260,  170,   38,   81,  257,  257,  170,  104,
 /*  1410 */    36,   22,  137,  134,   90,  236,  217,  235,   43,  201,
 /*  1420 */    96,   97,   48,  216,  138,  213,  216,  103,  217,  105,
 /*  1430 */   106,  107,   18,   59,  110,  170,   18,  169,  204,  204,
 /*  1440 */   204,  204,  213,  213,  201,   71,  170,  169,  146,  236,
 /*  1450 */   235,  127,  128,  201,  213,   62,   82,  170,  253,  169,
 /*  1460 */    22,   87,  189,  170,   90,  141,  142,  143,  144,  145,
 /*  1470 */    96,   97,  252,  169,  189,  104,  170,  103,  169,  105,
 /*  1480 */   106,  107,  186,  186,  110,  186,   64,  115,   19,   20,
 /*  1490 */   189,   22,  194,  186,  194,  246,  188,  186,  186,  186,
 /*  1500 */   102,  246,  133,  189,  189,   36,  104,  170,  228,   19,
 /*  1510 */    20,  227,   22,   84,   22,  141,  142,  143,  144,  145,
 /*  1520 */     0,    1,    2,  228,  271,    5,   36,  269,   59,   22,
 /*  1530 */    10,   11,   12,   13,   14,  216,  146,   17,  228,  217,
 /*  1540 */    71,  216,  136,  227,  227,  217,  228,  227,  170,   59,
 /*  1550 */    30,   82,   32,  215,  135,  214,   87,  213,   25,   90,
 /*  1560 */    40,   71,  241,   26,  173,   96,   97,  172,   13,  243,
 /*  1570 */     6,  164,  103,  164,  105,  106,  107,  162,  162,  110,
 /*  1580 */    90,  176,  162,  182,  176,  182,   96,   97,   98,  266,
 /*  1590 */    70,    4,  263,  103,  182,  105,  106,  107,   78,  266,
 /*  1600 */   110,   81,  176,  182,    3,  182,  182,  190,   88,  182,
 /*  1610 */   141,  142,  143,  144,  145,  190,  182,   22,  151,   15,
 /*  1620 */    89,   19,   20,   16,   22,  128,   23,  139,   23,  119,
 /*  1630 */    24,  141,  142,  143,  144,  145,  131,   20,   36,  133,
 /*  1640 */    16,    1,  122,  131,  140,  119,   61,  127,  128,   37,
 /*  1650 */   139,   53,   53,   53,  119,  105,   34,  130,    1,    5,
 /*  1660 */    22,   59,   53,  104,  149,   68,   75,   26,   41,  130,
 /*  1670 */   150,  104,   24,   71,  120,   20,   68,   19,   22,  114,
 /*  1680 */    67,   22,   22,   22,   82,   23,   67,   22,   67,   87,
 /*  1690 */    37,   28,   90,   23,  138,   22,  153,   23,   96,   97,
 /*  1700 */    23,   26,   23,   22,   24,  103,   23,  105,  106,  107,
 /*  1710 */     1,    2,  110,   22,    5,  105,   24,   23,  130,   10,
 /*  1720 */    11,   12,   13,   14,   23,   22,   17,   34,  132,   34,
 /*  1730 */    26,   19,   20,   34,   22,   85,   23,   26,   24,   30,
 /*  1740 */    44,   32,   75,  141,  142,  143,  144,  145,   36,   40,
 /*  1750 */    26,   83,   34,   23,   23,   23,   23,   23,   23,   11,
 /*  1760 */    22,   19,   20,   26,   22,   22,   22,   26,   23,   23,
 /*  1770 */   124,   59,   22,   22,  130,  130,   23,  130,   36,   70,
 /*  1780 */    15,  130,    1,   71,  277,  277,  277,   78,  277,  277,
 /*  1790 */    81,  277,  277,  277,  277,  277,  277,   88,  277,  277,
 /*  1800 */   277,   59,   90,  277,  277,  277,  277,  277,   96,   97,
 /*  1810 */   277,  277,  277,   71,  277,  103,  277,  105,  106,  107,
 /*  1820 */   277,  277,  110,  277,  277,  277,  277,  277,  277,  277,
 /*  1830 */   277,  122,   90,  277,  277,  277,  127,  128,   96,   97,
 /*  1840 */   277,  277,  277,  277,  277,  103,  277,  105,  106,  107,
 /*  1850 */   277,  277,  110,  141,  142,  143,  144,  145,  277,  150,
................................................................................
 /*  1960 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
 /*  1970 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
 /*  1980 */   122,  277,  277,  277,  277,  127,  128,  277,  277,  277,
 /*  1990 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
 /*  2000 */   277,  277,  277,  277,  277,  277,  277,  277,  150,  277,
 /*  2010 */   277,  277,  277,  277,  277,  277,  277,  277,  277,
};
#define YY_SHIFT_COUNT    (524)
#define YY_SHIFT_MIN      (0)
#define YY_SHIFT_MAX      (1858)
static const unsigned short int yy_shift_ofst[] = {
 /*     0 */  1709, 1520, 1858, 1324, 1324,  277, 1374, 1469, 1602, 1712,
 /*    10 */  1712, 1712,  273,    0,    0,  113, 1016, 1712, 1712, 1712,
 /*    20 */  1712, 1712, 1712, 1712, 1712, 1712, 1712,   11,   11,  236,
 /*    30 */   184,  277,  277,  277,  277,  277,  277,   93,  177,  270,
................................................................................
 /*   210 */   531,  531,  531,  531,  531,  531,  531,  531,  531,  531,
 /*   220 */   531,    2,    2,    2,  531,  531,  531,  531,  782,  531,
 /*   230 */   531,  531,  744,  531,  531,  783,  531,  531,  531,  531,
 /*   240 */   531,  531,  531,  531,  419,  682,  327,  370,  370,  370,
 /*   250 */   370, 1029,  327,  327, 1024,  897,  856,  947, 1109,  706,
 /*   260 */   706, 1143, 1109, 1109, 1143,  842,  945, 1118, 1136, 1136,
 /*   270 */  1136,  706,  676,  400, 1047,  694, 1339, 1270, 1270, 1366,
 /*   280 */  1366, 1270, 1305, 1389, 1275, 1279, 1375, 1275, 1279, 1286,
 /*   290 */  1414, 1414, 1414, 1414, 1270, 1418, 1286, 1286, 1305, 1389,
 /*   300 */  1375, 1375, 1286, 1270, 1418, 1302, 1393, 1270, 1418, 1438,
 /*   310 */  1270, 1418, 1270, 1418, 1438, 1371, 1371, 1371, 1422, 1438,
 /*   320 */  1371, 1372, 1371, 1422, 1371, 1371, 1438, 1398, 1398, 1438,
 /*   330 */  1369, 1402, 1369, 1402, 1369, 1402, 1369, 1402, 1270, 1279,
 /*   340 */  1429, 1492, 1275, 1279, 1507, 1270, 1390, 1275, 1406, 1419,
 /*   350 */  1286, 1533, 1537, 1555, 1555, 1564, 1564, 1564, 2009, 2009,
 /*   360 */  2009, 2009, 2009, 2009, 2009, 2009, 2009, 2009, 2009, 2009,
 /*   370 */  2009, 2009, 2009, 2009,  570,  345,  686,  748,   50,  740,
 /*   380 */  1064, 1107,  469,  537, 1042, 1146, 1162, 1154, 1201, 1202,
 /*   390 */  1203, 1208, 1209, 1127, 1069, 1196, 1157, 1147, 1226, 1228,
 /*   400 */  1245,  775,  868, 1246, 1247, 1191, 1151, 1587, 1601, 1595,
 /*   410 */  1467, 1604, 1531, 1607, 1603, 1605, 1497, 1488, 1510, 1606,
 /*   420 */  1505, 1617, 1506, 1624, 1640, 1512, 1504, 1526, 1585, 1612,
 /*   430 */  1511, 1598, 1599, 1600, 1609, 1535, 1550, 1622, 1527, 1657,
 /*   440 */  1654, 1638, 1559, 1515, 1597, 1641, 1608, 1591, 1627, 1539,
 /*   450 */  1567, 1648, 1655, 1658, 1554, 1565, 1656, 1613, 1659, 1660,
 /*   460 */  1662, 1661, 1619, 1663, 1665, 1621, 1653, 1670, 1556, 1673,
 /*   470 */  1543, 1674, 1677, 1675, 1679, 1681, 1680, 1683, 1691, 1692,
 /*   480 */  1588, 1694, 1701, 1610, 1693, 1703, 1596, 1704, 1695, 1704,
 /*   490 */  1699, 1650, 1667, 1668, 1696, 1713, 1714, 1711, 1724, 1718,
 /*   500 */  1730, 1704, 1731, 1732, 1733, 1734, 1737, 1735, 1738, 1748,
 /*   510 */  1743, 1744, 1745, 1746, 1750, 1751, 1741, 1646, 1644, 1645,
 /*   520 */  1647, 1651, 1753, 1765, 1781,
};
#define YY_REDUCE_COUNT (373)
#define YY_REDUCE_MIN   (-237)
#define YY_REDUCE_MAX   (1434)
static const short yy_reduce_ofst[] = {
 /*     0 */  -147,  171,  263,  -96,  358, -144, -149, -102,  124, -156,
 /*    10 */   -98,  305,  401,  -57,  209, -237,  245,  -94,  -79,  189,
 /*    20 */   375,  490,  493,  378,  303,  539,  542,  501,  503,  554,
 /*    30 */   415,  526,  546,  557,  587,  593,  595, -234, -234, -234,
 /*    40 */  -234, -234, -234, -234, -234, -234, -234, -234, -234, -234,
 /*    50 */  -234, -234, -234, -234, -234, -234, -234, -234, -234, -234,
................................................................................
 /*   210 */  1112, 1115, 1116, 1117, 1119, 1120, 1121, 1122, 1123, 1124,
 /*   220 */  1125, 1012, 1096, 1097, 1128, 1129, 1130, 1131, 1070, 1135,
 /*   230 */  1137, 1152, 1077, 1153, 1155, 1114, 1156,  304, 1158, 1172,
 /*   240 */  1173, 1174, 1175, 1176, 1089, 1091, 1133, 1098, 1126, 1139,
 /*   250 */  1140, 1070, 1133, 1133, 1170, 1163, 1186, 1103, 1168, 1138,
 /*   260 */  1141, 1110, 1169, 1171, 1132, 1177, 1189, 1194, 1181, 1200,
 /*   270 */  1204, 1166, 1145, 1178, 1187, 1232, 1142, 1231, 1233, 1149,
 /*   280 */  1150, 1238, 1179, 1182, 1199, 1207, 1218, 1211, 1210, 1212,
 /*   290 */  1234, 1235, 1236, 1237, 1265, 1268, 1229, 1230, 1213, 1215,
 /*   300 */  1243, 1252, 1241, 1276, 1278, 1205, 1220, 1287, 1290, 1273,
 /*   310 */  1293, 1304, 1306, 1309, 1285, 1296, 1297, 1299, 1298, 1301,
 /*   320 */  1307, 1308, 1311, 1300, 1312, 1313, 1314, 1249, 1255, 1315,
 /*   330 */  1280, 1284, 1295, 1316, 1310, 1317, 1318, 1320, 1337, 1319,
 /*   340 */  1253, 1258, 1322, 1325, 1321, 1378, 1326, 1328, 1338, 1341,
 /*   350 */  1344, 1391, 1395, 1407, 1409, 1415, 1416, 1420, 1323, 1333,
 /*   360 */  1329, 1405, 1401, 1403, 1412, 1421, 1408, 1417, 1425, 1423,
 /*   370 */  1424, 1427, 1434, 1426,
};
static const YYACTIONTYPE yy_default[] = {

 /*     0 */  1496, 1496, 1496, 1344, 1127, 1233, 1127, 1127, 1127, 1344,
 /*    10 */  1344, 1344, 1127, 1263, 1263, 1395, 1158, 1127, 1127, 1127,
 /*    20 */  1127, 1127, 1127, 1127, 1343, 1127, 1127, 1127, 1127, 1127,
 /*    30 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1269, 1127,
 /*    40 */  1127, 1127, 1127, 1127, 1345, 1346, 1127, 1127, 1127, 1394,
 /*    50 */  1396, 1279, 1278, 1277, 1276, 1377, 1250, 1274, 1267, 1271,
 /*    60 */  1339, 1340, 1338, 1342, 1346, 1345, 1127, 1270, 1310, 1324,
 /*    70 */  1309, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*    80 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*    90 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   100 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   110 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1318, 1323, 1329,
 /*   120 */  1322, 1319, 1312, 1311, 1313, 1314, 1127, 1148, 1197, 1127,
 /*   130 */  1127, 1127, 1127, 1413, 1412, 1127, 1127, 1158, 1315, 1316,
 /*   140 */  1326, 1325, 1402, 1452, 1451, 1127, 1127, 1127, 1127, 1127,
 /*   150 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   160 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   170 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1158, 1154, 1304,
 /*   180 */  1303, 1422, 1154, 1257, 1127, 1408, 1233, 1224, 1127, 1127,
 /*   190 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   200 */  1127, 1399, 1397, 1127, 1359, 1127, 1127, 1127, 1127, 1127,
 /*   210 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   220 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   230 */  1127, 1127, 1229, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   240 */  1127, 1127, 1127, 1446, 1127, 1372, 1211, 1229, 1229, 1229,
 /*   250 */  1229, 1231, 1212, 1210, 1223, 1158, 1134, 1488, 1273, 1252,
 /*   260 */  1252, 1485, 1273, 1273, 1485, 1172, 1466, 1169, 1263, 1263,
 /*   270 */  1263, 1252, 1341, 1230, 1223, 1127, 1488, 1238, 1238, 1487,
 /*   280 */  1487, 1238, 1282, 1288, 1268, 1257, 1200, 1268, 1257, 1273,
 /*   290 */  1206, 1206, 1206, 1206, 1238, 1145, 1273, 1273, 1282, 1288,
 /*   300 */  1200, 1200, 1273, 1238, 1145, 1376, 1482, 1238, 1145, 1352,
 /*   310 */  1238, 1145, 1238, 1145, 1352, 1198, 1198, 1198, 1187, 1352,
 /*   320 */  1198, 1172, 1198, 1187, 1198, 1198, 1352, 1356, 1356, 1352,
 /*   330 */  1256, 1251, 1256, 1251, 1256, 1251, 1256, 1251, 1238, 1257,
 /*   340 */  1421, 1127, 1268, 1257, 1347, 1238, 1127, 1268, 1266, 1264,
 /*   350 */  1273, 1151, 1190, 1449, 1449, 1445, 1445, 1445, 1493, 1493,
 /*   360 */  1408, 1461, 1158, 1158, 1158, 1158, 1461, 1174, 1174, 1158,
 /*   370 */  1158, 1158, 1158, 1461, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   380 */  1456, 1127, 1361, 1242, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   390 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   400 */  1127, 1127, 1127, 1127, 1127, 1127, 1293, 1127, 1130, 1405,
 /*   410 */  1127, 1127, 1403, 1127, 1127, 1127, 1127, 1127, 1127, 1243,
 /*   420 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   430 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1484, 1127,
 /*   440 */  1127, 1127, 1127, 1127, 1127, 1375, 1374, 1127, 1127, 1240,
 /*   450 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   460 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   470 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   480 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1265, 1127, 1420,
 /*   490 */  1127, 1127, 1127, 1127, 1127, 1127, 1127, 1434, 1258, 1127,
 /*   500 */  1127, 1475, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127,
 /*   510 */  1127, 1127, 1127, 1127, 1127, 1127, 1470, 1214, 1295, 1127,
 /*   520 */  1294, 1298, 1127, 1139, 1127,
};
/********** End of lemon-generated parsing tables *****************************/

/* The next table maps tokens (terminal symbols) into fallback tokens.  
** If a construct like the following:
** 
**      %fallback ID X Y Z.
................................................................................
 /* 135 */ "groupby_opt ::= GROUP BY nexprlist",
 /* 136 */ "having_opt ::=",
 /* 137 */ "having_opt ::= HAVING expr",
 /* 138 */ "limit_opt ::=",
 /* 139 */ "limit_opt ::= LIMIT expr",
 /* 140 */ "limit_opt ::= LIMIT expr OFFSET expr",
 /* 141 */ "limit_opt ::= LIMIT expr COMMA expr",
 /* 142 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt orderby_opt limit_opt",
 /* 143 */ "where_opt ::=",
 /* 144 */ "where_opt ::= WHERE expr",
 /* 145 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist where_opt orderby_opt limit_opt",
 /* 146 */ "setlist ::= setlist COMMA nm EQ expr",
 /* 147 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
 /* 148 */ "setlist ::= nm EQ expr",
 /* 149 */ "setlist ::= LP idlist RP EQ expr",
 /* 150 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
 /* 151 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES",
 /* 152 */ "upsert ::=",
................................................................................
  {  214,   -3 }, /* (135) groupby_opt ::= GROUP BY nexprlist */
  {  215,    0 }, /* (136) having_opt ::= */
  {  215,   -2 }, /* (137) having_opt ::= HAVING expr */
  {  217,    0 }, /* (138) limit_opt ::= */
  {  217,   -2 }, /* (139) limit_opt ::= LIMIT expr */
  {  217,   -4 }, /* (140) limit_opt ::= LIMIT expr OFFSET expr */
  {  217,   -4 }, /* (141) limit_opt ::= LIMIT expr COMMA expr */
  {  160,   -8 }, /* (142) cmd ::= with DELETE FROM xfullname indexed_opt where_opt orderby_opt limit_opt */
  {  213,    0 }, /* (143) where_opt ::= */
  {  213,   -2 }, /* (144) where_opt ::= WHERE expr */
  {  160,  -10 }, /* (145) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist where_opt orderby_opt limit_opt */
  {  233,   -5 }, /* (146) setlist ::= setlist COMMA nm EQ expr */
  {  233,   -7 }, /* (147) setlist ::= setlist COMMA LP idlist RP EQ expr */
  {  233,   -3 }, /* (148) setlist ::= nm EQ expr */
  {  233,   -5 }, /* (149) setlist ::= LP idlist RP EQ expr */
  {  160,   -7 }, /* (150) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
  {  160,   -7 }, /* (151) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */
  {  236,    0 }, /* (152) upsert ::= */
................................................................................
        break;
      case 140: /* limit_opt ::= LIMIT expr OFFSET expr */
{yymsp[-3].minor.yy18 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy18,yymsp[0].minor.yy18);}
        break;
      case 141: /* limit_opt ::= LIMIT expr COMMA expr */
{yymsp[-3].minor.yy18 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy18,yymsp[-2].minor.yy18);}
        break;
      case 142: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt orderby_opt limit_opt */
{
  sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy135, &yymsp[-3].minor.yy0);
  sqlite3DeleteFrom(pParse,yymsp[-4].minor.yy135,yymsp[-2].minor.yy18,yymsp[-1].minor.yy420,yymsp[0].minor.yy18);
}
        break;
      case 145: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist where_opt orderby_opt limit_opt */
{
  sqlite3SrcListIndexedBy(pParse, yymsp[-6].minor.yy135, &yymsp[-5].minor.yy0);
  sqlite3ExprListCheckLength(pParse,yymsp[-3].minor.yy420,"set list"); 
  sqlite3Update(pParse,yymsp[-6].minor.yy135,yymsp[-3].minor.yy420,yymsp[-2].minor.yy18,yymsp[-7].minor.yy70,yymsp[-1].minor.yy420,yymsp[0].minor.yy18,0);
}
        break;
      case 146: /* setlist ::= setlist COMMA nm EQ expr */
{
  yymsp[-4].minor.yy420 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy420, yymsp[0].minor.yy18);
  sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy420, &yymsp[-2].minor.yy0, 1);
}
................................................................................
             yyTracePrompt,yyTokenName[yymajor]);
        }
#endif
        yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
        yymajor = YYNOCODE;
      }else{
        while( yypParser->yytos >= yypParser->yystack
            && yymx != YYERRORSYMBOL
            && (yyact = yy_find_reduce_action(
                        yypParser->yytos->stateno,
                        YYERRORSYMBOL)) >= YY_MIN_REDUCE
        ){
          yy_pop_parser_stack(yypParser);
        }
        if( yypParser->yytos < yypParser->yystack || yymajor==0 ){
          yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
          yy_parse_failed(yypParser);
#ifndef YYNOERRORRECOVERY
................................................................................
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff);
      break;
    }

    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
    **
    ** If parameter onoff is non-zero, configure the wrappers so that all
    ** subsequent calls to localtime() and variants fail. If onoff is zero,
    ** undo this setting.
    */
    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
      break;
    }













    /*   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
................................................................................
    }
    assert( pToken->pSegcsr==0 );
  }

  return rc;
}


/*
** This function is called on each phrase after the position lists for
** any deferred tokens have been loaded into memory. It updates the phrases
** current position list to include only those positions that are really
** instances of the phrase (after considering deferred tokens). If this
** means that the phrase does not appear in the current row, doclist.pList
** and doclist.nList are both zeroed.
................................................................................
      }
      sqlite3_free(aPoslist);
    }
  }

  return SQLITE_OK;
}


/*
** Maximum number of tokens a phrase may have to be considered for the
** incremental doclists strategy.
*/
#define MAX_INCR_PHRASE_TOKENS 4

................................................................................
#define JEACH_VALUE   1
#define JEACH_TYPE    2
#define JEACH_ATOM    3
#define JEACH_ID      4
#define JEACH_PARENT  5
#define JEACH_FULLKEY 6
#define JEACH_PATH    7



#define JEACH_JSON    8
#define JEACH_ROOT    9

  UNUSED_PARAM(pzErr);
  UNUSED_PARAM(argv);
  UNUSED_PARAM(argc);
  UNUSED_PARAM(pAux);
................................................................................
** 1 if the constraint is found, 3 if the constraint and zRoot are found,
** and 0 otherwise.
*/
static int jsonEachBestIndex(
  sqlite3_vtab *tab,
  sqlite3_index_info *pIdxInfo
){
  int i;
  int jsonIdx = -1;
  int rootIdx = -1;

  const struct sqlite3_index_constraint *pConstraint;




  UNUSED_PARAM(tab);

  pConstraint = pIdxInfo->aConstraint;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){






    if( pConstraint->usable==0 ) continue;

    if( pConstraint->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    switch( pConstraint->iColumn ){
      case JEACH_JSON:   jsonIdx = i;    break;
      case JEACH_ROOT:   rootIdx = i;    break;
      default:           /* no-op */     break;


    }
  }
  if( jsonIdx<0 ){









    pIdxInfo->idxNum = 0;
    pIdxInfo->estimatedCost = 1e99;
  }else{
    pIdxInfo->estimatedCost = 1.0;

    pIdxInfo->aConstraintUsage[jsonIdx].argvIndex = 1;
    pIdxInfo->aConstraintUsage[jsonIdx].omit = 1;
    if( rootIdx<0 ){

      pIdxInfo->idxNum = 1;
    }else{

      pIdxInfo->aConstraintUsage[rootIdx].argvIndex = 2;
      pIdxInfo->aConstraintUsage[rootIdx].omit = 1;
      pIdxInfo->idxNum = 3;
    }
  }
  return SQLITE_OK;
}

/* Start a search on a new JSON string */
static int jsonEachFilter(
................................................................................
  int argc,
  sqlite3_value **argv
){
  GeoPoly *p = geopolyFuncParam(context, argv[0], 0);
  if( p ){
    if( geopolyArea(p)<0.0 ){
      int ii, jj;
      for(ii=2, jj=p->nVertex*2 - 4; ii<jj; ii+=2, jj-=2){
        GeoCoord t = p->a[ii];
        p->a[ii] = p->a[jj];
        p->a[jj] = t;
        t = p->a[ii+1];
        p->a[ii+1] = p->a[jj+1];
        p->a[jj+1] = t;
      }
................................................................................
** operate on a different database schema, so check for it.
**
** idxNum is normally 0, but will be 1 if a schema=? constraint exists.
*/
static int statBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
  int i;

  pIdxInfo->estimatedCost = 1.0e6;  /* Initial cost estimate */

  /* Look for a valid schema=? constraint.  If found, change the idxNum to
  ** 1 and request the value of that constraint be sent to xFilter.  And
  ** lower the cost estimate to encourage the constrained version to be
  ** used.
  */
  for(i=0; i<pIdxInfo->nConstraint; i++){

    if( pIdxInfo->aConstraint[i].usable==0 ) continue;
    if( pIdxInfo->aConstraint[i].op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    if( pIdxInfo->aConstraint[i].iColumn!=10 ) continue;
    pIdxInfo->idxNum = 1;
    pIdxInfo->estimatedCost = 1.0;
    pIdxInfo->aConstraintUsage[i].argvIndex = 1;
    pIdxInfo->aConstraintUsage[i].omit = 1;
    break;
  }

................................................................................
        if( nLocal<0 ) goto statPageIsCorrupt;
        pCell->nLocal = nLocal;
        assert( nPayload>=(u32)nLocal );
        assert( nLocal<=(nUsable-35) );
        if( nPayload>(u32)nLocal ){
          int j;
          int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4);

          pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);
          pCell->nOvfl = nOvfl;
          pCell->aOvfl = sqlite3_malloc64(sizeof(u32)*nOvfl);
          if( pCell->aOvfl==0 ) return SQLITE_NOMEM_BKPT;
          pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
          for(j=1; j<nOvfl; j++){
            int rc;
................................................................................
  ** unavailable
  */
  for(i=0; i<pIdxInfo->nConstraint; i++){
    struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[i];
    if( p->iColumn!=DBPAGE_COLUMN_SCHEMA ) continue;
    if( p->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    if( !p->usable ){
      /* No solution.  Use the default SQLITE_BIG_DBL cost */
      pIdxInfo->estimatedRows = 0x7fffffff;
      return SQLITE_OK;
    }
    iPlan = 2;
    pIdxInfo->aConstraintUsage[i].argvIndex = 1;
    pIdxInfo->aConstraintUsage[i].omit = 1;
    break;
  }

................................................................................
** of this template is copied straight through into the generate parser
** source file.
**
** The following is the concatenation of all %include directives from the
** input grammar file:
*/
/* #include <stdio.h> */

/************ Begin %include sections from the grammar ************************/

/* #include "fts5Int.h" */
/* #include "fts5parse.h" */

/*
** Disable all error recovery processing in the parser push-down
................................................................................
             fts5yyTracePrompt,fts5yyTokenName[fts5yymajor]);
        }
#endif
        fts5yy_destructor(fts5yypParser, (fts5YYCODETYPE)fts5yymajor, &fts5yyminorunion);
        fts5yymajor = fts5YYNOCODE;
      }else{
        while( fts5yypParser->fts5yytos >= fts5yypParser->fts5yystack
            && fts5yymx != fts5YYERRORSYMBOL
            && (fts5yyact = fts5yy_find_reduce_action(
                        fts5yypParser->fts5yytos->stateno,
                        fts5YYERRORSYMBOL)) >= fts5YY_MIN_REDUCE
        ){
          fts5yy_pop_parser_stack(fts5yypParser);
        }
        if( fts5yypParser->fts5yytos < fts5yypParser->fts5yystack || fts5yymajor==0 ){
          fts5yy_destructor(fts5yypParser,(fts5YYCODETYPE)fts5yymajor,&fts5yyminorunion);
          fts5yy_parse_failed(fts5yypParser);
#ifndef fts5YYNOERRORRECOVERY
................................................................................
static void fts5SourceIdFunc(
  sqlite3_context *pCtx,          /* Function call context */
  int nArg,                       /* Number of args */
  sqlite3_value **apUnused        /* Function arguments */
){
  assert( nArg==0 );
  UNUSED_PARAM2(nArg, apUnused);
  sqlite3_result_text(pCtx, "fts5: 2018-11-12 15:20:44 f9755f81b1c0fd29f242dce78a2fba570fa2714d76e93b8563f426a040352513", -1, SQLITE_TRANSIENT);
}

/*
** Return true if zName is the extension on one of the shadow tables used
** by this module.
*/
static int fts5ShadowName(const char *zName){
................................................................................
#endif
  return rc;
}
#endif /* SQLITE_CORE */
#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */

/************** End of stmt.c ************************************************/
#if __LINE__!=220418
#undef SQLITE_SOURCE_ID
#define SQLITE_SOURCE_ID      "2018-11-12 15:20:44 f9755f81b1c0fd29f242dce78a2fba570fa2714d76e93b8563f426a04035alt2"
#endif
/* Return the source-id for this library */
SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
/************************** End of sqlite3.c ******************************/

**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
*/
#define SQLITE_VERSION        "3.26.0"
#define SQLITE_VERSION_NUMBER 3026000
#define SQLITE_SOURCE_ID      "2018-11-28 11:49:46 b53a9a3dc6b0422a102b245451769b0cd8c0d67090fefabf7cb3a65137a73771"

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
................................................................................
#define SQLITE_TESTCTRL_PENDING_BYTE            11
#define SQLITE_TESTCTRL_ASSERT                  12
#define SQLITE_TESTCTRL_ALWAYS                  13
#define SQLITE_TESTCTRL_RESERVE                 14
#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
#define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */
#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS      17
#define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
#define SQLITE_TESTCTRL_EXPLAIN_STMT            19  /* NOT USED */
#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
#define SQLITE_TESTCTRL_NEVER_CORRUPT           20
#define SQLITE_TESTCTRL_VDBE_COVERAGE           21
#define SQLITE_TESTCTRL_BYTEORDER               22
#define SQLITE_TESTCTRL_ISINIT                  23
................................................................................

#ifndef SQLITE_OMIT_WAL
SQLITE_PRIVATE   int sqlite3PagerCheckpoint(Pager *pPager, sqlite3*, int, int*, int*);
SQLITE_PRIVATE   int sqlite3PagerWalSupported(Pager *pPager);
SQLITE_PRIVATE   int sqlite3PagerWalCallback(Pager *pPager);
SQLITE_PRIVATE   int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
SQLITE_PRIVATE   int sqlite3PagerCloseWal(Pager *pPager, sqlite3*);



# ifdef SQLITE_ENABLE_SNAPSHOT
SQLITE_PRIVATE   int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot);
SQLITE_PRIVATE   int sqlite3PagerSnapshotOpen(Pager *pPager, sqlite3_snapshot *pSnapshot);
SQLITE_PRIVATE   int sqlite3PagerSnapshotRecover(Pager *pPager);
SQLITE_PRIVATE   int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot);
SQLITE_PRIVATE   void sqlite3PagerSnapshotUnlock(Pager *pPager);
# endif
#endif


#ifdef SQLITE_DIRECT_OVERFLOW_READ
SQLITE_PRIVATE   int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno);
#endif

#ifdef SQLITE_ENABLE_ZIPVFS
SQLITE_PRIVATE   int sqlite3PagerWalFramesize(Pager *pPager);
#endif

/* Functions used to query pager state and configuration. */
................................................................................

/* Return the header size */
SQLITE_PRIVATE int sqlite3HeaderSizePcache(void);
SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void);

/* Number of dirty pages as a percentage of the configured cache size */
SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache*);

#ifdef SQLITE_DIRECT_OVERFLOW_READ
SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache);
#endif

#endif /* _PCACHE_H_ */

/************** End of pcache.h **********************************************/
/************** Continuing where we left off in sqliteInt.h ******************/
/************** Include os.h in the middle of sqliteInt.h ********************/
/************** Begin file os.h **********************************************/
................................................................................
#define SQLITE_FUNC_UNLIKELY 0x0400 /* Built-in unlikely() function */
#define SQLITE_FUNC_CONSTANT 0x0800 /* Constant inputs give a constant output */
#define SQLITE_FUNC_MINMAX   0x1000 /* True for min() and max() aggregates */
#define SQLITE_FUNC_SLOCHNG  0x2000 /* "Slow Change". Value constant during a
                                    ** single query - might change over time */
#define SQLITE_FUNC_AFFINITY 0x4000 /* Built-in affinity() function */
#define SQLITE_FUNC_OFFSET   0x8000 /* Built-in sqlite_offset() function */
#define SQLITE_FUNC_WINDOW   0x00010000 /* Built-in window-only function */
#define SQLITE_FUNC_WINDOW_SIZE 0x20000 /* Requires partition size as arg. */
#define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */

/*
** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
** used to create the initializers for the FuncDef structures.
**
**   FUNCTION(zName, nArg, iArg, bNC, xFunc)
**     Used to create a scalar function definition of a function zName
................................................................................
   (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
#define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue) \
  {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \
   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,0,#zName, {0}}
#define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \
  {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \
   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xFinal,0,#zName, {0}}

#define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \
  {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \
   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
#define INTERNAL_FUNCTION(zName, nArg, xFunc) \
  {nArg, SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
   0, 0, xFunc, 0, 0, 0, #zName, {0} }


/*
** All current savepoints are stored in a linked list starting at
** sqlite3.pSavepoint. The first element in the list is the most recently
** opened savepoint. Savepoints are added to the list by the vdbe
** OP_Savepoint instruction.
*/
................................................................................
  void (*xVdbeBranch)(void*,unsigned iSrcLine,u8 eThis,u8 eMx);  /* Callback */
  void *pVdbeBranchArg;                                     /* 1st argument */
#endif
#ifndef SQLITE_UNTESTABLE
  int (*xTestCallback)(int);        /* Invoked by sqlite3FaultSim() */
#endif
  int bLocaltimeFault;              /* True to fail localtime() calls */
  int bInternalFunctions;           /* Internal SQL functions are visible */
  int iOnceResetThreshold;          /* When to reset OP_Once counters */
  u32 szSorterRef;                  /* Min size in bytes to use sorter-refs */
};

/*
** This macro is used inside of assert() statements to indicate that
** the assert is only valid on a well-formed database.  Instead of:
................................................................................
   0,                         /* xVdbeBranch */
   0,                         /* pVbeBranchArg */
#endif
#ifndef SQLITE_UNTESTABLE
   0,                         /* xTestCallback */
#endif
   0,                         /* bLocaltimeFault */
   0,                         /* bInternalFunctions */
   0x7ffffffe,                /* iOnceResetThreshold */
   SQLITE_DEFAULT_SORTERREF_SIZE   /* szSorterRef */
};

/*
** Hash table for global functions - functions common to all
** database connections.  After initialization, this table is
................................................................................
SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3*, AuxData**, int, int);

int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(sqlite3*,VdbeCursor*,UnpackedRecord*,int*);
SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3*, BtCursor*, i64*);
SQLITE_PRIVATE int sqlite3VdbeExec(Vdbe*);
#ifndef SQLITE_OMIT_EXPLAIN
SQLITE_PRIVATE int sqlite3VdbeList(Vdbe*);
#endif
SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe*);
SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int);
SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*);
SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*);
SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*);
................................................................................
SQLITE_PRIVATE void sqlite3VdbeMemCast(Mem*,u8,u8);
SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,Mem*);
SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
#ifndef SQLITE_OMIT_WINDOWFUNC
SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem*, Mem*, FuncDef*);
#endif
#ifndef SQLITE_OMIT_EXPLAIN
SQLITE_PRIVATE const char *sqlite3OpcodeName(int);
#endif
SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int n);
SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int);
#ifdef SQLITE_DEBUG
SQLITE_PRIVATE int sqlite3VdbeFrameIsValid(VdbeFrame*);
#endif
SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void*);      /* Destructor on Mem */
................................................................................
  winceLock local;        /* Locks obtained by this instance of winFile */
  winceLock *shared;      /* Global shared lock memory for the file  */
#endif
#if SQLITE_MAX_MMAP_SIZE>0
  int nFetchOut;                /* Number of outstanding xFetch references */
  HANDLE hMap;                  /* Handle for accessing memory mapping */
  void *pMapRegion;             /* Area memory mapped */
  sqlite3_int64 mmapSize;       /* Size of mapped region */

  sqlite3_int64 mmapSizeMax;    /* Configured FCNTL_MMAP_SIZE value */
#endif
};

/*
** The winVfsAppData structure is used for the pAppData member for all of the
** Win32 VFS variants.
................................................................................
*/
static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
  winFile *pFile = (winFile*)id;  /* File handle object */
  int rc = SQLITE_OK;             /* Return code for this function */
  DWORD lastErrno;
#if SQLITE_MAX_MMAP_SIZE>0
  sqlite3_int64 oldMmapSize;
  if( pFile->nFetchOut>0 ){
    /* File truncation is a no-op if there are outstanding memory mapped
    ** pages.  This is because truncating the file means temporarily unmapping
    ** the file, and that might delete memory out from under existing cursors.
    **
    ** This can result in incremental vacuum not truncating the file,
    ** if there is an active read cursor when the incremental vacuum occurs.
    ** No real harm comes of this - the database file is not corrupted,
    ** though some folks might complain that the file is bigger than it
    ** needs to be.
    **
    ** The only feasible work-around is to defer the truncation until after
    ** all references to memory-mapped content are closed.  That is doable,
    ** but involves adding a few branches in the common write code path which
    ** could slow down normal operations slightly.  Hence, we have decided for
    ** now to simply make trancations a no-op if there are pending reads.  We
    ** can maybe revisit this decision in the future.
    */
    return SQLITE_OK;
  }
#endif

  assert( pFile );
  SimulateIOError(return SQLITE_IOERR_TRUNCATE);
  OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, size=%lld, lock=%d\n",
           osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype));

................................................................................
/*
** Cleans up the mapped region of the specified file, if any.
*/
#if SQLITE_MAX_MMAP_SIZE>0
static int winUnmapfile(winFile *pFile){
  assert( pFile!=0 );
  OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, pMapRegion=%p, "
           "mmapSize=%lld, mmapSizeMax=%lld\n",
           osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion,
           pFile->mmapSize, pFile->mmapSizeMax));
  if( pFile->pMapRegion ){
    if( !osUnmapViewOfFile(pFile->pMapRegion) ){
      pFile->lastErrno = osGetLastError();
      OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, pMapRegion=%p, "
               "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(), pFile,
               pFile->pMapRegion));
      return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
                         "winUnmapfile1", pFile->zPath);
    }
    pFile->pMapRegion = 0;
    pFile->mmapSize = 0;

  }
  if( pFile->hMap!=NULL ){
    if( !osCloseHandle(pFile->hMap) ){
      pFile->lastErrno = osGetLastError();
      OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, rc=SQLITE_IOERR_MMAP\n",
               osGetCurrentProcessId(), pFile, pFile->hMap));
      return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
................................................................................
      /* Log the error, but continue normal operation using xRead/xWrite */
      OSTRACE(("MAP-FILE-MAP pid=%lu, pFile=%p, rc=%s\n",
               osGetCurrentProcessId(), pFd, sqlite3ErrName(rc)));
      return SQLITE_OK;
    }
    pFd->pMapRegion = pNew;
    pFd->mmapSize = nMap;

  }

  OSTRACE(("MAP-FILE pid=%lu, pFile=%p, rc=SQLITE_OK\n",
           osGetCurrentProcessId(), pFd));
  return SQLITE_OK;
}
#endif /* SQLITE_MAX_MMAP_SIZE>0 */
................................................................................
  }
  pFile->lastErrno = NO_ERROR;
  pFile->zPath = zName;
#if SQLITE_MAX_MMAP_SIZE>0
  pFile->hMap = NULL;
  pFile->pMapRegion = 0;
  pFile->mmapSize = 0;

  pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap;
#endif

  OpenCounter(+1);
  return rc;
}

................................................................................
SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache *pCache){
  PgHdr *pDirty;
  int nDirty = 0;
  int nCache = numberOfCachePages(pCache);
  for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext) nDirty++;
  return nCache ? (int)(((i64)nDirty * 100) / nCache) : 0;
}

#ifdef SQLITE_DIRECT_OVERFLOW_READ
/* 
** Return true if there are one or more dirty pages in the cache. Else false.
*/
SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache){
  return (pCache->pDirty!=0);
}
#endif

#if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG)
/*
** For all dirty pages currently in the cache, invoke the specified
** callback. This is only used if the SQLITE_CHECK_PAGES macro is
** defined.
*/
................................................................................
  PgHdr1 *pNext;                 /* Next in hash table chain */
  PCache1 *pCache;               /* Cache that currently owns this page */
  PgHdr1 *pLruNext;              /* Next in LRU list of unpinned pages */
  PgHdr1 *pLruPrev;              /* Previous in LRU list of unpinned pages */
};

/*
** A page is pinned if it is not on the LRU list.  To be "pinned" means
** that the page is in active use and must not be deallocated.
*/
#define PAGE_IS_PINNED(p)    ((p)->pLruNext==0)
#define PAGE_IS_UNPINNED(p)  ((p)->pLruNext!=0)

/* Each page cache (or PCache) belongs to a PGroup.  A PGroup is a set 
** of one or more PCaches that are able to recycle each other's unpinned
** pages when they are under memory pressure.  A PGroup is an instance of
................................................................................
**
** instead of
**
**   if( pPager->jfd->pMethods ){ ...
*/
#define isOpen(pFd) ((pFd)->pMethods!=0)

#ifdef SQLITE_DIRECT_OVERFLOW_READ
/*

** Return true if page pgno can be read directly from the database file
** by the b-tree layer. This is the case if:
**
**   * the database file is open,
**   * there are no dirty pages in the cache, and
**   * the desired page is not currently in the wal file.
*/

SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){
  if( pPager->fd->pMethods==0 ) return 0;
  if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0;
#ifndef SQLITE_OMIT_WAL
  if( pPager->pWal ){
    u32 iRead = 0;
    int rc;

    rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
    return (rc==SQLITE_OK && iRead==0);
  }
#endif
  return 1;
}
#endif

#ifndef SQLITE_OMIT_WAL
# define pagerUseWal(x) ((x)->pWal!=0)
#else
# define pagerUseWal(x) 0
# define pagerRollbackWal(x) 0
# define pagerWalFrames(v,w,x,y) 0
# define pagerOpenWalIfPresent(z) SQLITE_OK
................................................................................
SQLITE_PRIVATE void sqlite3PagerSetCodec(
  Pager *pPager,
  void *(*xCodec)(void*,void*,Pgno,int),
  void (*xCodecSizeChng)(void*,int,int),
  void (*xCodecFree)(void*),
  void *pCodec
){
  if( pPager->xCodecFree ){
    pPager->xCodecFree(pPager->pCodec);
  }else{
    pager_reset(pPager);
  }
  pPager->xCodec = pPager->memDb ? 0 : xCodec;
  pPager->xCodecSizeChng = xCodecSizeChng;
  pPager->xCodecFree = xCodecFree;
  pPager->pCodec = pCodec;
  setGetterMethod(pPager);
  pagerReportSize(pPager);
}
................................................................................
          rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
        }
        offset -= ovflSize;
      }else{
        /* Need to read this page properly. It contains some of the
        ** range of data that is being read (eOp==0) or written (eOp!=0).
        */



        int a = amt;
        if( a + offset > ovflSize ){
          a = ovflSize - offset;
        }

#ifdef SQLITE_DIRECT_OVERFLOW_READ
        /* If all the following are true:
        **
        **   1) this is a read operation, and 
        **   2) data is required from the start of this overflow page, and
        **   3) there are no dirty pages in the page-cache
        **   4) the database is file-backed, and
        **   5) the page is not in the WAL file
        **   6) at least 4 bytes have already been read into the output buffer 
        **
        ** then data can be read directly from the database file into the
        ** output buffer, bypassing the page-cache altogether. This speeds
        ** up loading large records that span many overflow pages.
        */
        if( eOp==0                                             /* (1) */
         && offset==0                                          /* (2) */


         && sqlite3PagerDirectReadOk(pBt->pPager, nextPage)    /* (3,4,5) */
         && &pBuf[-4]>=pBufStart                               /* (6) */
        ){
          sqlite3_file *fd = sqlite3PagerFile(pBt->pPager);
          u8 aSave[4];
          u8 *aWrite = &pBuf[-4];
          assert( aWrite>=pBufStart );                         /* due to (6) */
          memcpy(aSave, aWrite, 4);
          rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));
          nextPage = get4byte(aWrite);
          memcpy(aWrite, aSave, 4);
................................................................................
        if( (pDef->funcFlags & SQLITE_FUNC_CONSTANT)==0 ){
          /* Date/time functions that use 'now', and other functions like
          ** sqlite_version() that might change over time cannot be used
          ** in an index. */
          notValid(pParse, pNC, "non-deterministic functions",
                   NC_IdxExpr|NC_PartIdx);
        }
        if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0
         && pParse->nested==0
         && sqlite3Config.bInternalFunctions==0
        ){
          /* Internal-use-only functions are disallowed unless the
          ** SQL is being compiled using sqlite3NestedParse() */
          no_such_func = 1;
          pDef = 0;
        }
      }

      if( 0==IN_RENAME_OBJECT ){
#ifndef SQLITE_OMIT_WINDOWFUNC
        assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
          || (pDef->xValue==0 && pDef->xInverse==0)
          || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
................................................................................
  }
}
#else
# define renameTokenCheckAll(x,y)
#endif

/*
** Remember that the parser tree element pPtr was created using
** the token pToken.
**
** In other words, construct a new RenameToken object and add it
** to the list of RenameToken objects currently being built up
** in pParse->pRename.
**
** The pPtr argument is returned so that this routine can be used
** with tail recursion in tokenExpr() routine, for a small performance
** improvement.
*/
SQLITE_PRIVATE void *sqlite3RenameTokenMap(Parse *pParse, void *pPtr, Token *pToken){
  RenameToken *pNew;
  assert( pPtr || pParse->db->mallocFailed );
  renameTokenCheckAll(pParse, pPtr);
  pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
  if( pNew ){
................................................................................
**   8. bTemp:    True if zSql comes from temp schema
**
** Do a column rename operation on the CREATE statement given in zSql.
** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
** into zNew.  The name should be quoted if bQuote is true.
**
** This function is used internally by the ALTER TABLE RENAME COLUMN command.
** It is only accessible to SQL created using sqlite3NestedParse().  It is
** not reachable from ordinary SQL passed into sqlite3_prepare().







*/
static void renameColumnFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  sqlite3 *db = sqlite3_context_db_handle(context);
................................................................................
}

/*
** Register built-in functions used to help implement ALTER TABLE
*/
SQLITE_PRIVATE void sqlite3AlterFunctions(void){
  static FuncDef aAlterTableFuncs[] = {
    INTERNAL_FUNCTION(sqlite_rename_column, 9, renameColumnFunc),
    INTERNAL_FUNCTION(sqlite_rename_table,  7, renameTableFunc),
    INTERNAL_FUNCTION(sqlite_rename_test,   5, renameTableTest),
  };
  sqlite3InsertBuiltinFuncs(aAlterTableFuncs, ArraySize(aAlterTableFuncs));
}
#endif  /* SQLITE_ALTER_TABLE */

/************** End of alter.c ***********************************************/
/************** Begin file analyze.c *****************************************/
................................................................................
    ** reopen it as a MemDB */
    pVfs = sqlite3_vfs_find("memdb");
    if( pVfs==0 ) return;
    pNew = &db->aDb[db->init.iDb];
    if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt);
    pNew->pBt = 0;
    pNew->pSchema = 0;
    rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);
  }else{
    /* This is a real ATTACH
    **
    ** Check for the following errors:
    **
    **     * Too many attached databases,
    **     * Transaction currently open
................................................................................
/*
** Erase all schema information from all attached databases (including
** "main" and "temp") for a single database connection.
*/
SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
  int i;
  sqlite3BtreeEnterAll(db);

  for(i=0; i<db->nDb; i++){
    Db *pDb = &db->aDb[i];
    if( pDb->pSchema ){
      if( db->nSchemaLock==0 ){
        sqlite3SchemaClear(pDb->pSchema);
      }else{
        DbSetProperty(db, i, DB_ResetWanted);
      }
    }
  }
  db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
  sqlite3VtabUnlockList(db);
  sqlite3BtreeLeaveAll(db);
  if( db->nSchemaLock==0 ){
    sqlite3CollapseDatabaseArray(db);
  }
}

/*
** This routine is called when a commit occurs.
*/
SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){
  db->mDbFlags &= ~DBFLAG_SchemaChange;
................................................................................
    assert( pTab->nCol==j );
  }else{
    pPk->nColumn = pTab->nCol;
  }
  recomputeColumnsNotIndexed(pPk);
}

#ifndef SQLITE_OMIT_VIRTUALTABLE
/*
** Return true if zName is a shadow table name in the current database
** connection.
**
** zName is temporarily modified while this routine is running, but is
** restored to its original value prior to this routine returning.
*/
................................................................................
  if( !IsVirtual(pTab) ) return 0;
  pMod = (Module*)sqlite3HashFind(&db->aModule, pTab->azModuleArg[0]);
  if( pMod==0 ) return 0;
  if( pMod->pModule->iVersion<3 ) return 0;
  if( pMod->pModule->xShadowName==0 ) return 0;
  return pMod->pModule->xShadowName(zTail+1);
}
#else
# define isShadowTableName(x,y) 0
#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */

/*
** This routine is called to report the final ")" that terminates
** a CREATE TABLE statement.
**
** The table structure that other action routines have been building
** is added to the internal hash tables, assuming no errors have
................................................................................
  }
  if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0;
  db = pParse->db;
  if( (pTab->tabFlags & TF_Readonly)!=0 ){
    return sqlite3WritableSchema(db)==0 && pParse->nested==0;
  }
  assert( pTab->tabFlags & TF_Shadow );
  return (db->flags & SQLITE_Defensive)!=0 
#ifndef SQLITE_OMIT_VIRTUALTABLE
          && db->pVtabCtx==0
#endif
          && db->nVdbeExec==0;
}

/*
** Check to make sure the given table is writable.  If it is not
** writable, generate an error message and return 1.  If it is
** writable return 0;
*/
................................................................................

#ifdef SQLITE_OMIT_VIRTUALTABLE
# define sqlite3_create_module 0
# define sqlite3_create_module_v2 0
# define sqlite3_declare_vtab 0
# define sqlite3_vtab_config 0
# define sqlite3_vtab_on_conflict 0
# define sqlite3_vtab_collation 0
#endif

#ifdef SQLITE_OMIT_SHARED_CACHE
# define sqlite3_enable_shared_cache 0
#endif

#if defined(SQLITE_OMIT_TRACE) || defined(SQLITE_OMIT_DEPRECATED)
................................................................................
  ** dflt_value: The default value for the column, if any.
  ** pk:         Non-zero for PK fields.
  */
  case PragTyp_TABLE_INFO: if( zRight ){
    Table *pTab;
    pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
    if( pTab ){
      int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
      int i, k;
      int nHidden = 0;
      Column *pCol;
      Index *pPk = sqlite3PrimaryKeyIndex(pTab);
      pParse->nMem = 7;
      sqlite3CodeVerifySchema(pParse, iTabDb);
      sqlite3ViewGetColumnNames(pParse, pTab);
      for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
        int isHidden = IsHiddenColumn(pCol);
        if( isHidden && pPragma->iArg==0 ){
          nHidden++;
          continue;
        }
................................................................................
#endif

  case PragTyp_INDEX_INFO: if( zRight ){
    Index *pIdx;
    Table *pTab;
    pIdx = sqlite3FindIndex(db, zRight, zDb);
    if( pIdx ){
      int iIdxDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
      int i;
      int mx;
      if( pPragma->iArg ){
        /* PRAGMA index_xinfo (newer version with more rows and columns) */
        mx = pIdx->nColumn;
        pParse->nMem = 6;
      }else{
        /* PRAGMA index_info (legacy version) */
        mx = pIdx->nKeyCol;
        pParse->nMem = 3;
      }
      pTab = pIdx->pTable;
      sqlite3CodeVerifySchema(pParse, iIdxDb);
      assert( pParse->nMem<=pPragma->nPragCName );
      for(i=0; i<mx; i++){
        i16 cnum = pIdx->aiColumn[i];
        sqlite3VdbeMultiLoad(v, 1, "iisX", i, cnum,
                             cnum<0 ? 0 : pTab->aCol[cnum].zName);
        if( pPragma->iArg ){
          sqlite3VdbeMultiLoad(v, 4, "isiX",
................................................................................

  case PragTyp_INDEX_LIST: if( zRight ){
    Index *pIdx;
    Table *pTab;
    int i;
    pTab = sqlite3FindTable(db, zRight, zDb);
    if( pTab ){
      int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
      pParse->nMem = 5;
      sqlite3CodeVerifySchema(pParse, iTabDb);
      for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
        const char *azOrigin[] = { "c", "u", "pk" };
        sqlite3VdbeMultiLoad(v, 1, "isisi",
           i,
           pIdx->zName,
           IsUniqueIndex(pIdx),
           azOrigin[pIdx->idxType],
................................................................................
  case PragTyp_FUNCTION_LIST: {
    int i;
    HashElem *j;
    FuncDef *p;
    pParse->nMem = 2;
    for(i=0; i<SQLITE_FUNC_HASH_SZ; i++){
      for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash ){
        if( p->funcFlags & SQLITE_FUNC_INTERNAL ) continue;
        sqlite3VdbeMultiLoad(v, 1, "si", p->zName, 1);
      }
    }
    for(j=sqliteHashFirst(&db->aFunc); j; j=sqliteHashNext(j)){
      p = (FuncDef*)sqliteHashData(j);
      sqlite3VdbeMultiLoad(v, 1, "si", p->zName, 0);
    }
................................................................................
  case PragTyp_FOREIGN_KEY_LIST: if( zRight ){
    FKey *pFK;
    Table *pTab;
    pTab = sqlite3FindTable(db, zRight, zDb);
    if( pTab ){
      pFK = pTab->pFKey;
      if( pFK ){
        int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
        int i = 0; 
        pParse->nMem = 8;
        sqlite3CodeVerifySchema(pParse, iTabDb);
        while(pFK){
          int j;
          for(j=0; j<pFK->nCol; j++){
            sqlite3VdbeMultiLoad(v, 1, "iissssss",
                   i,
                   j,
                   pFK->zTo,
................................................................................
    int addrOk;            /* Jump here if the key is OK */
    int *aiCols;           /* child to parent column mapping */

    regResult = pParse->nMem+1;
    pParse->nMem += 4;
    regKey = ++pParse->nMem;
    regRow = ++pParse->nMem;

    k = sqliteHashFirst(&db->aDb[iDb].pSchema->tblHash);
    while( k ){
      int iTabDb;
      if( zRight ){
        pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
        k = 0;
      }else{
        pTab = (Table*)sqliteHashData(k);
        k = sqliteHashNext(k);
      }
      if( pTab==0 || pTab->pFKey==0 ) continue;
      iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
      sqlite3CodeVerifySchema(pParse, iTabDb);
      sqlite3TableLock(pParse, iTabDb, pTab->tnum, 0, pTab->zName);
      if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
      sqlite3OpenTable(pParse, 0, iTabDb, pTab, OP_OpenRead);
      sqlite3VdbeLoadString(v, regResult, pTab->zName);
      for(i=1, pFK=pTab->pFKey; pFK; i++, pFK=pFK->pNextFrom){
        pParent = sqlite3FindTable(db, pFK->zTo, zDb);
        if( pParent==0 ) continue;
        pIdx = 0;
        sqlite3TableLock(pParse, iTabDb, pParent->tnum, 0, pParent->zName);
        x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0);
        if( x==0 ){
          if( pIdx==0 ){
            sqlite3OpenTable(pParse, i, iTabDb, pParent, OP_OpenRead);
          }else{
            sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iTabDb);
            sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
          }
        }else{
          k = 0;
          break;
        }
      }
................................................................................

/*
** The table object reference passed as the second argument to this function
** must represent a virtual table. This function invokes the xBestIndex()
** method of the virtual table with the sqlite3_index_info object that
** comes in as the 3rd argument to this function.
**
** If an error occurs, pParse is populated with an error message and an
** appropriate error code is returned.  A return of SQLITE_CONSTRAINT from
** xBestIndex is not considered an error.  SQLITE_CONSTRAINT indicates that
** the current configuration of "unusable" flags in sqlite3_index_info can
** not result in a valid plan.
**
** Whether or not an error is returned, it is the responsibility of the
** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates
** that this is required.
*/
static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
  sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
  int rc;

  TRACE_IDX_INPUTS(p);
  rc = pVtab->pModule->xBestIndex(pVtab, p);
  TRACE_IDX_OUTPUTS(p);

  if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){
    if( rc==SQLITE_NOMEM ){
      sqlite3OomFault(pParse->db);
    }else if( !pVtab->zErrMsg ){
      sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
    }else{
      sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
    }
  }
  sqlite3_free(pVtab->zErrMsg);
  pVtab->zErrMsg = 0;












  return rc;
}
#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */

#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
/*
** Estimate the location of a particular key among all keys in an
** index.  Store the results in aStat as follows:
................................................................................
  pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2;
  pIdxInfo->estimatedRows = 25;
  pIdxInfo->idxFlags = 0;
  pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed;

  /* Invoke the virtual table xBestIndex() method */
  rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);
  if( rc ){
    if( rc==SQLITE_CONSTRAINT ){
      /* If the xBestIndex method returns SQLITE_CONSTRAINT, that means
      ** that the particular combination of parameters provided is unusable.
      ** Make no entries in the loop table.
      */
      WHERETRACE(0xffff, ("  ^^^^--- non-viable plan rejected!\n"));
      return SQLITE_OK;
    }
    return rc;
  }

  mxTerm = -1;
  assert( pNew->nLSlot>=nConstraint );
  for(i=0; i<nConstraint; i++) pNew->aLTerm[i] = 0;
  pNew->u.vtab.omitMask = 0;
  pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
  for(i=0; i<nConstraint; i++, pIdxCons++){
................................................................................
** of this template is copied straight through into the generate parser
** source file.
**
** The following is the concatenation of all %include directives from the
** input grammar file:
*/
/* #include <stdio.h> */
/* #include <assert.h> */
/************ Begin %include sections from the grammar ************************/

/* #include "sqliteInt.h" */

/*
** Disable all error recovery processing in the parser push-down
** automaton.
................................................................................
#define sqlite3ParserARG_STORE
#define sqlite3ParserCTX_SDECL Parse *pParse;
#define sqlite3ParserCTX_PDECL ,Parse *pParse
#define sqlite3ParserCTX_PARAM ,pParse
#define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
#define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
#define YYFALLBACK 1
#define YYNSTATE             521
#define YYNRULE              367
#define YYNTOKEN             155
#define YY_MAX_SHIFT         520
#define YY_MIN_SHIFTREDUCE   756
#define YY_MAX_SHIFTREDUCE   1122
#define YY_ERROR_ACTION      1123
#define YY_ACCEPT_ACTION     1124
#define YY_NO_ACTION         1125
#define YY_MIN_REDUCE        1126
#define YY_MAX_REDUCE        1492
/************* End control #defines *******************************************/
#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

/* Define the yytestcase() macro to be a no-op if is not already defined
** otherwise.
**
** Applications can choose to define yytestcase() in the %include section
................................................................................
**  yy_reduce_ofst[]   For each state, the offset into yy_action for
**                     shifting non-terminals after a reduce.
**  yy_default[]       Default action for each state.
**
*********** Begin parsing tables **********************************************/
#define YY_ACTTAB_COUNT (2009)
static const YYACTIONTYPE yy_action[] = {
 /*     0 */   368,  105,  102,  197,  105,  102,  197,  515, 1124,    1,
 /*    10 */     1,  520,    2, 1128,  515, 1192, 1171, 1456,  275,  370,
 /*    20 */   127, 1389, 1197, 1197, 1192, 1166,  178, 1205,   64,   64,
 /*    30 */   477,  887,  322,  428,  348,   37,   37,  808,  362,  888,
 /*    40 */   509,  509,  509,  112,  113,  103, 1100, 1100,  953,  956,
 /*    50 */   946,  946,  110,  110,  111,  111,  111,  111,  365,  252,
 /*    60 */   252,  515,  252,  252,  497,  515,  309,  515,  459,  515,
 /*    70 */  1079,  491,  512,  478,    6,  512,  809,  134,  498,  228,
 /*    80 */   194,  428,   37,   37,  515,  208,   64,   64,   64,   64,
 /*    90 */    13,   13,  109,  109,  109,  109,  108,  108,  107,  107,
 /*   100 */   107,  106,  401,  258,  381,   13,   13,  398,  397,  428,
 /*   110 */   252,  252,  370,  476,  405, 1104, 1079, 1080, 1081,  386,
 /*   120 */  1106,  390,  497,  512,  497, 1423, 1419,  304, 1105,  307,
 /*   130 */  1256,  496,  370,  499,   16,   16,  112,  113,  103, 1100,
 /*   140 */  1100,  953,  956,  946,  946,  110,  110,  111,  111,  111,
 /*   150 */   111,  262, 1107,  495, 1107,  401,  112,  113,  103, 1100,
 /*   160 */  1100,  953,  956,  946,  946,  110,  110,  111,  111,  111,
 /*   170 */   111,  129, 1425,  343, 1420,  339, 1059,  492, 1057,  263,
 /*   180 */    73,  105,  102,  197,  994,  109,  109,  109,  109,  108,
 /*   190 */   108,  107,  107,  107,  106,  401,  370,  111,  111,  111,
 /*   200 */   111,  104,  492,   89, 1432,  109,  109,  109,  109,  108,
 /*   210 */   108,  107,  107,  107,  106,  401,  111,  111,  111,  111,
 /*   220 */   112,  113,  103, 1100, 1100,  953,  956,  946,  946,  110,
 /*   230 */   110,  111,  111,  111,  111,  109,  109,  109,  109,  108,
 /*   240 */   108,  107,  107,  107,  106,  401,  114,  108,  108,  107,
 /*   250 */   107,  107,  106,  401,  109,  109,  109,  109,  108,  108,
 /*   260 */   107,  107,  107,  106,  401,  152,  399,  399,  399,  109,
 /*   270 */   109,  109,  109,  108,  108,  107,  107,  107,  106,  401,
 /*   280 */   178,  493, 1412,  434, 1037, 1486, 1079,  515, 1486,  370,
 /*   290 */   421,  297,  357,  412,   74, 1079,  109,  109,  109,  109,
 /*   300 */   108,  108,  107,  107,  107,  106,  401, 1413,   37,   37,
 /*   310 */  1431,  274,  506,  112,  113,  103, 1100, 1100,  953,  956,
 /*   320 */   946,  946,  110,  110,  111,  111,  111,  111, 1436,  520,
 /*   330 */     2, 1128, 1079, 1080, 1081,  430,  275, 1079,  127,  366,
 /*   340 */   933, 1079, 1080, 1081,  220, 1205,  913,  458,  455,  454,
 /*   350 */   392,  167,  515, 1035,  152,  445,  924,  453,  152,  874,
 /*   360 */   923,  289,  109,  109,  109,  109,  108,  108,  107,  107,
 /*   370 */   107,  106,  401,   13,   13,  261,  853,  252,  252,  227,
 /*   380 */   106,  401,  370, 1079, 1080, 1081,  311,  388, 1079,  296,
 /*   390 */   512,  923,  923,  925,  231,  323, 1255, 1388, 1423,  490,
 /*   400 */   274,  506,   12,  208,  274,  506,  112,  113,  103, 1100,
 /*   410 */  1100,  953,  956,  946,  946,  110,  110,  111,  111,  111,
 /*   420 */   111, 1440,  286, 1128,  288, 1079, 1097,  247,  275, 1098,
 /*   430 */   127,  387,  405,  389, 1079, 1080, 1081, 1205,  159,  238,
 /*   440 */   255,  321,  461,  316,  460,  225,  790,  105,  102,  197,
 /*   450 */   513,  314,  842,  842,  445,  109,  109,  109,  109,  108,
 /*   460 */   108,  107,  107,  107,  106,  401,  515,  514,  515,  252,
 /*   470 */   252, 1079, 1080, 1081,  435,  370, 1098,  933, 1460,  794,
 /*   480 */   274,  506,  512,  105,  102,  197,  336,   63,   63,   64,
 /*   490 */    64,   27,  790,  924,  287,  208, 1354,  923,  515,  112,
 /*   500 */   113,  103, 1100, 1100,  953,  956,  946,  946,  110,  110,
 /*   510 */   111,  111,  111,  111,  107,  107,  107,  106,  401,   49,
 /*   520 */    49,  515,   28, 1079,  405,  497,  421,  297,  923,  923,
 /*   530 */   925,  186,  468, 1079,  467,  999,  999,  442,  515, 1079,
 /*   540 */   334,  515,   45,   45, 1083,  342,  173,  168,  109,  109,
 /*   550 */   109,  109,  108,  108,  107,  107,  107,  106,  401,   13,
 /*   560 */    13,  205,   13,   13,  252,  252, 1195, 1195,  370, 1079,
 /*   570 */  1080, 1081,  787,  265,    5,  359,  494,  512,  469, 1079,
 /*   580 */  1080, 1081,  398,  397, 1079, 1079, 1080, 1081,    3,  282,
 /*   590 */  1079, 1083,  112,  113,  103, 1100, 1100,  953,  956,  946,
 /*   600 */   946,  110,  110,  111,  111,  111,  111,  252,  252, 1015,
 /*   610 */   220, 1079,  873,  458,  455,  454,  943,  943,  954,  957,
 /*   620 */   512,  252,  252,  453, 1016, 1079,  445, 1107, 1209, 1107,
 /*   630 */  1079, 1080, 1081,  515,  512,  426, 1079, 1080, 1081, 1017,
 /*   640 */   512,  109,  109,  109,  109,  108,  108,  107,  107,  107,
 /*   650 */   106,  401, 1052,  515,   50,   50,  515, 1079, 1080, 1081,
 /*   660 */   828,  370, 1051,  379,  411, 1064, 1358,  207,  408,  773,
 /*   670 */   829, 1079, 1080, 1081,   64,   64,  322,   64,   64, 1302,
 /*   680 */   947,  411,  410, 1358, 1360,  112,  113,  103, 1100, 1100,
 /*   690 */   953,  956,  946,  946,  110,  110,  111,  111,  111,  111,
 /*   700 */   294,  482,  515, 1037, 1487,  515,  434, 1487,  354, 1120,
 /*   710 */   483,  996,  913,  485,  466,  996,  132,  178,   33,  450,
 /*   720 */  1203,  136,  406,   64,   64,  479,   64,   64,  419,  369,
 /*   730 */   283, 1146,  252,  252,  109,  109,  109,  109,  108,  108,
 /*   740 */   107,  107,  107,  106,  401,  512,  224,  440,  411,  266,
 /*   750 */  1358,  266,  252,  252,  370,  296,  416,  284,  934,  396,
 /*   760 */   976,  470,  400,  252,  252,  512,    9,  473,  231,  500,
 /*   770 */   354, 1036, 1035, 1488,  355,  374,  512, 1121,  112,  113,
 /*   780 */   103, 1100, 1100,  953,  956,  946,  946,  110,  110,  111,
 /*   790 */   111,  111,  111,  252,  252, 1015,  515, 1347,  295,  252,
 /*   800 */   252,  252,  252, 1098,  375,  249,  512,  445,  872,  322,
 /*   810 */  1016,  480,  512,  195,  512,  434,  273,   15,   15,  515,
 /*   820 */   314,  515,   95,  515,   93, 1017,  367,  109,  109,  109,
 /*   830 */   109,  108,  108,  107,  107,  107,  106,  401,  515, 1121,
 /*   840 */    39,   39,   51,   51,   52,   52,  503,  370,  515, 1204,
 /*   850 */  1098,  918,  439,  341,  133,  436,  223,  222,  221,   53,
 /*   860 */    53,  322, 1400,  761,  762,  763,  515,  370,   88,   54,
 /*   870 */    54,  112,  113,  103, 1100, 1100,  953,  956,  946,  946,
 /*   880 */   110,  110,  111,  111,  111,  111,  407,   55,   55,  196,
 /*   890 */   515,  112,  113,  103, 1100, 1100,  953,  956,  946,  946,
 /*   900 */   110,  110,  111,  111,  111,  111,  135,  264, 1149,  376,
 /*   910 */   515,   40,   40,  515,  872,  515,  993,  515,  993,  116,
 /*   920 */   109,  109,  109,  109,  108,  108,  107,  107,  107,  106,
 /*   930 */   401,   41,   41,  515,   43,   43,   44,   44,   56,   56,
 /*   940 */   109,  109,  109,  109,  108,  108,  107,  107,  107,  106,
 /*   950 */   401,  515,  379,  515,   57,   57,  515,  799,  515,  379,
 /*   960 */   515,  445,  200,  515,  323,  515, 1397,  515, 1459,  515,
 /*   970 */  1287,  817,   58,   58,   14,   14,  515,   59,   59,  118,
 /*   980 */   118,   60,   60,  515,   46,   46,   61,   61,   62,   62,
 /*   990 */    47,   47,  515,  190,  189,   91,  515,  140,  140,  515,
 /*  1000 */   394,  515,  277, 1200,  141,  141,  515, 1115,  515,  992,
 /*  1010 */   515,  992,  515,   69,   69,  370,  278,   48,   48,  259,
 /*  1020 */    65,   65,  119,  119,  246,  246,  260,   66,   66,  120,
 /*  1030 */   120,  121,  121,  117,  117,  370,  515,  512,  383,  112,
 /*  1040 */   113,  103, 1100, 1100,  953,  956,  946,  946,  110,  110,
 /*  1050 */   111,  111,  111,  111,  515,  872,  515,  139,  139,  112,
 /*  1060 */   113,  103, 1100, 1100,  953,  956,  946,  946,  110,  110,
 /*  1070 */   111,  111,  111,  111, 1287,  138,  138,  125,  125,  515,
 /*  1080 */    12,  515,  281, 1287,  515,  445,  131, 1287,  109,  109,
 /*  1090 */   109,  109,  108,  108,  107,  107,  107,  106,  401,  515,
 /*  1100 */   124,  124,  122,  122,  515,  123,  123,  515,  109,  109,
 /*  1110 */   109,  109,  108,  108,  107,  107,  107,  106,  401,  515,
 /*  1120 */    68,   68,  463,  783,  515,   70,   70,  302,   67,   67,
 /*  1130 */  1032,  253,  253,  356, 1287,  191,  196, 1433,  465, 1301,
 /*  1140 */    38,   38,  384,   94,  512,   42,   42,  177,  848,  274,
 /*  1150 */   506,  385,  420,  847, 1356,  441,  508,  376,  377,  153,
 /*  1160 */   423,  872,  432,  370,  224,  251,  194,  887,  182,  293,
 /*  1170 */   783,  848,   88,  254,  466,  888,  847,  915,  807,  806,
 /*  1180 */   230, 1241,  910,  370,   17,  413,  797,  112,  113,  103,
 /*  1190 */  1100, 1100,  953,  956,  946,  946,  110,  110,  111,  111,
 /*  1200 */   111,  111,  395,  814,  815, 1175,  983,  112,  101,  103,
 /*  1210 */  1100, 1100,  953,  956,  946,  946,  110,  110,  111,  111,
 /*  1220 */   111,  111,  375,  422,  427,  429,  298,  230,  230,   88,
 /*  1230 */  1240,  451,  312,  797,  226,   88,  109,  109,  109,  109,
 /*  1240 */   108,  108,  107,  107,  107,  106,  401,   86,  433,  979,
 /*  1250 */   927,  881,  226,  983,  230,  415,  109,  109,  109,  109,
 /*  1260 */   108,  108,  107,  107,  107,  106,  401,  320,  845,  781,
 /*  1270 */   846,  100,  130,  100, 1403,  290,  370,  319, 1377, 1376,
 /*  1280 */   437, 1449,  299, 1237,  303,  306,  308,  310, 1188, 1174,
 /*  1290 */  1173, 1172,  315,  324,  325, 1228,  370,  927, 1249,  271,
 /*  1300 */  1286,  113,  103, 1100, 1100,  953,  956,  946,  946,  110,
 /*  1310 */   110,  111,  111,  111,  111, 1224, 1235,  502,  501, 1292,
 /*  1320 */  1221, 1155,  103, 1100, 1100,  953,  956,  946,  946,  110,
 /*  1330 */   110,  111,  111,  111,  111, 1148, 1137, 1136, 1138, 1443,
 /*  1340 */   446,  244,  184,   98,  507,  188,    4,  353,  327,  109,
 /*  1350 */   109,  109,  109,  108,  108,  107,  107,  107,  106,  401,
 /*  1360 */   510,  329,  331,  199,  414,  456,  292,  285,  318,  109,
 /*  1370 */   109,  109,  109,  108,  108,  107,  107,  107,  106,  401,
 /*  1380 */    11, 1271, 1279,  402,  361,  192, 1171, 1351,  431,  505,
 /*  1390 */   346, 1350,  333,   98,  507,  504,    4,  187, 1446, 1115,
 /*  1400 */   233, 1396,  155, 1394, 1112,  152,   72,   75,  378,  425,
 /*  1410 */   510,  165,  149,  157,  933, 1276,   86,   30, 1268,  417,
 /*  1420 */    96,   96,    8,  160,  161,  162,  163,   97,  418,  402,
 /*  1430 */   517,  516,  449,  402,  923,  210,  358,  424, 1282,  438,
 /*  1440 */   169,  214,  360, 1345,   80,  504,   31,  444, 1365,  301,
 /*  1450 */   245,  274,  506,  216,  174,  305,  488,  447,  217,  462,
 /*  1460 */  1139,  487,  218,  363,  933,  923,  923,  925,  926,   24,
 /*  1470 */    96,   96, 1191, 1190, 1189,  391, 1182,   97, 1163,  402,
 /*  1480 */   517,  516,  799,  364,  923, 1162,  317, 1161,   98,  507,
 /*  1490 */  1181,    4, 1458,  472,  393,  269,  270,  475,  481, 1232,
 /*  1500 */    85, 1233,  326,  328,  232,  510,  495, 1231,  330,   98,
 /*  1510 */   507, 1230,    4,  486,  335,  923,  923,  925,  926,   24,
 /*  1520 */  1435, 1068,  404,  181,  336,  256,  510,  115,  402,  332,
 /*  1530 */   352,  352,  351,  241,  349, 1214, 1414,  770,  338,   10,
 /*  1540 */   504,  340,  272,   92, 1331, 1213,   87,  183,  484,  402,
 /*  1550 */   201,  488,  280,  239,  344,  345,  489, 1145,   29,  933,
 /*  1560 */   279,  504, 1074,  518,  240,   96,   96,  242,  243,  519,
 /*  1570 */  1134, 1129,   97,  154,  402,  517,  516,  372,  373,  923,
 /*  1580 */   933,  142,  143,  128, 1381,  267,   96,   96,  852,  757,
 /*  1590 */   203,  144,  403,   97, 1382,  402,  517,  516,  204, 1380,
 /*  1600 */   923,  146, 1379, 1159, 1158,   71, 1156,  276,  202,  185,
 /*  1610 */   923,  923,  925,  926,   24,  198,  257,  126,  991,  989,
 /*  1620 */   907,   98,  507,  156,    4,  145,  158,  206,  831,  209,
 /*  1630 */   291,  923,  923,  925,  926,   24, 1005,  911,  510,  164,
 /*  1640 */   147,  380,  371,  382,  166,   76,   77,  274,  506,  148,
 /*  1650 */    78,   79, 1008,  211,  212, 1004,  137,  213,   18,  300,
 /*  1660 */   230,  402,  997, 1109,  443,  215,   32,  170,  171,  772,
 /*  1670 */   409,  448,  319,  504,  219,  172,  452,   81,   19,  457,
 /*  1680 */   313,   20,   82,  268,  488,  150,  810,  179,   83,  487,
 /*  1690 */   464,  151,  933,  180,  959,   84, 1040,   34,   96,   96,
 /*  1700 */   471, 1041,   35,  474,  193,   97,  248,  402,  517,  516,
 /*  1710 */  1068,  404,  923,  250,  256,  880,  229,  175,  875,  352,
 /*  1720 */   352,  351,  241,  349,  100,   21,  770,   22, 1054, 1056,
 /*  1730 */     7,   98,  507, 1045,    4,  337, 1058,   23,  974,  201,
 /*  1740 */   176,  280,   88,  923,  923,  925,  926,   24,  510,  279,
 /*  1750 */   960,  958,  962, 1014,  963, 1013,  235,  234,   25,   36,
 /*  1760 */    99,   90,  507,  928,    4,  511,  350,  782,   26,  841,
 /*  1770 */   236,  402,  347, 1069,  237, 1125, 1125, 1451,  510,  203,
 /*  1780 */  1450, 1125, 1125,  504, 1125, 1125, 1125,  204, 1125, 1125,
 /*  1790 */   146, 1125, 1125, 1125, 1125, 1125, 1125,  202, 1125, 1125,
 /*  1800 */  1125,  402,  933, 1125, 1125, 1125, 1125, 1125,   96,   96,
 /*  1810 */  1125, 1125, 1125,  504, 1125,   97, 1125,  402,  517,  516,
 /*  1820 */  1125, 1125,  923, 1125, 1125, 1125, 1125, 1125, 1125, 1125,
 /*  1830 */  1125,  371,  933, 1125, 1125, 1125,  274,  506,   96,   96,
 /*  1840 */  1125, 1125, 1125, 1125, 1125,   97, 1125,  402,  517,  516,
 /*  1850 */  1125, 1125,  923,  923,  923,  925,  926,   24, 1125,  409,
 /*  1860 */  1125, 1125, 1125,  256, 1125, 1125, 1125, 1125,  352,  352,
 /*  1870 */   351,  241,  349, 1125, 1125,  770, 1125, 1125, 1125, 1125,
 /*  1880 */  1125, 1125, 1125,  923,  923,  925,  926,   24,  201, 1125,
 /*  1890 */   280, 1125, 1125, 1125, 1125, 1125, 1125, 1125,  279, 1125,
 /*  1900 */  1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125,
 /*  1910 */  1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125,
 /*  1920 */  1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125,  203, 1125,
 /*  1930 */  1125, 1125, 1125, 1125, 1125, 1125,  204, 1125, 1125,  146,
 /*  1940 */  1125, 1125, 1125, 1125, 1125, 1125,  202, 1125, 1125, 1125,
 /*  1950 */  1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125,
 /*  1960 */  1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125,
 /*  1970 */  1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125,
 /*  1980 */   371, 1125, 1125, 1125, 1125,  274,  506, 1125, 1125, 1125,
 /*  1990 */  1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125,
 /*  2000 */  1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125,  409,
};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */   184,  238,  239,  240,  238,  239,  240,  163,  155,  156,
 /*    10 */   157,  158,  159,  160,  163,  191,  192,  183,  165,   19,
 /*    20 */   167,  258,  202,  203,  200,  191,  163,  174,  184,  185,
 /*    30 */   174,   31,  163,  163,  171,  184,  185,   35,  175,   39,
 /*    40 */   179,  180,  181,   43,   44,   45,   46,   47,   48,   49,
................................................................................
 /*  1340 */   251,  250,  209,   19,   20,  182,   22,  161,  222,   92,
 /*  1350 */    93,   94,   95,   96,   97,   98,   99,  100,  101,  102,
 /*  1360 */    36,  222,  222,  260,  226,  188,  256,  226,  187,   92,
 /*  1370 */    93,   94,   95,   96,   97,   98,   99,  100,  101,  102,
 /*  1380 */   210,  213,  213,   59,  213,  196,  192,  187,  256,  244,
 /*  1390 */   212,  187,  226,   19,   20,   71,   22,  210,  166,   60,
 /*  1400 */   130,  170,  260,  170,   38,   81,  257,  257,  170,  104,
 /*  1410 */    36,   22,   43,  201,   90,  236,  138,  235,  213,   18,
 /*  1420 */    96,   97,   48,  204,  204,  204,  204,  103,  170,  105,
 /*  1430 */   106,  107,   18,   59,  110,  169,  213,  213,  201,  170,
 /*  1440 */   201,  169,  236,  213,  146,   71,  235,   62,  253,  252,
 /*  1450 */   170,  127,  128,  169,   22,  170,   82,  189,  169,  104,
 /*  1460 */   170,   87,  169,  189,   90,  141,  142,  143,  144,  145,
 /*  1470 */    96,   97,  186,  186,  186,   64,  194,  103,  186,  105,
 /*  1480 */   106,  107,  115,  189,  110,  188,  186,  186,   19,   20,
 /*  1490 */   194,   22,  186,  189,  102,  246,  246,  189,  133,  228,
 /*  1500 */   104,  228,  227,  227,  170,   36,  134,  228,  227,   19,
 /*  1510 */    20,  228,   22,   84,  271,  141,  142,  143,  144,  145,
 /*  1520 */     0,    1,    2,  216,   22,    5,   36,  137,   59,  227,
 /*  1530 */    10,   11,   12,   13,   14,  217,  269,   17,  216,   22,
 /*  1540 */    71,  170,  243,  146,  241,  217,  136,  215,  135,   59,
 /*  1550 */    30,   82,   32,   25,  214,  213,   87,  173,   26,   90,
 /*  1560 */    40,   71,   13,  172,  164,   96,   97,  164,    6,  162,
 /*  1570 */   162,  162,  103,  263,  105,  106,  107,  266,  266,  110,
 /*  1580 */    90,  176,  176,  190,  182,  190,   96,   97,   98,    4,
 /*  1590 */    70,  176,    3,  103,  182,  105,  106,  107,   78,  182,
 /*  1600 */   110,   81,  182,  182,  182,  182,  182,  151,   88,   22,
 /*  1610 */   141,  142,  143,  144,  145,   15,   89,   16,   23,   23,
 /*  1620 */   128,   19,   20,  139,   22,  119,  131,   24,   20,  133,
 /*  1630 */    16,  141,  142,  143,  144,  145,    1,  140,   36,  131,
 /*  1640 */   119,   61,  122,   37,  139,   53,   53,  127,  128,  119,
 /*  1650 */    53,   53,  105,   34,  130,    1,    5,  104,   22,  149,
 /*  1660 */    26,   59,   68,   75,   41,  130,   24,   68,  104,   20,
 /*  1670 */   150,   19,  120,   71,  114,   22,   67,   22,   22,   67,
 /*  1680 */    23,   22,   22,   67,   82,   37,   28,   23,  138,   87,
 /*  1690 */    22,  153,   90,   23,   23,   26,   23,   22,   96,   97,
 /*  1700 */    24,   23,   22,   24,  130,  103,   23,  105,  106,  107,
 /*  1710 */     1,    2,  110,   23,    5,  105,   34,   22,  132,   10,
 /*  1720 */    11,   12,   13,   14,   26,   34,   17,   34,   85,   83,
 /*  1730 */    44,   19,   20,   23,   22,   24,   75,   34,   23,   30,
 /*  1740 */    26,   32,   26,  141,  142,  143,  144,  145,   36,   40,
 /*  1750 */    23,   23,   23,   23,   11,   23,   22,   26,   22,   22,
 /*  1760 */    22,   19,   20,   23,   22,   26,   15,   23,   22,  124,
 /*  1770 */   130,   59,   23,    1,  130,  277,  277,  130,   36,   70,
 /*  1780 */   130,  277,  277,   71,  277,  277,  277,   78,  277,  277,
 /*  1790 */    81,  277,  277,  277,  277,  277,  277,   88,  277,  277,
 /*  1800 */   277,   59,   90,  277,  277,  277,  277,  277,   96,   97,
 /*  1810 */   277,  277,  277,   71,  277,  103,  277,  105,  106,  107,
 /*  1820 */   277,  277,  110,  277,  277,  277,  277,  277,  277,  277,
 /*  1830 */   277,  122,   90,  277,  277,  277,  127,  128,   96,   97,
 /*  1840 */   277,  277,  277,  277,  277,  103,  277,  105,  106,  107,
 /*  1850 */   277,  277,  110,  141,  142,  143,  144,  145,  277,  150,
................................................................................
 /*  1960 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
 /*  1970 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
 /*  1980 */   122,  277,  277,  277,  277,  127,  128,  277,  277,  277,
 /*  1990 */   277,  277,  277,  277,  277,  277,  277,  277,  277,  277,
 /*  2000 */   277,  277,  277,  277,  277,  277,  277,  277,  150,  277,
 /*  2010 */   277,  277,  277,  277,  277,  277,  277,  277,  277,
};
#define YY_SHIFT_COUNT    (520)
#define YY_SHIFT_MIN      (0)
#define YY_SHIFT_MAX      (1858)
static const unsigned short int yy_shift_ofst[] = {
 /*     0 */  1709, 1520, 1858, 1324, 1324,  277, 1374, 1469, 1602, 1712,
 /*    10 */  1712, 1712,  273,    0,    0,  113, 1016, 1712, 1712, 1712,
 /*    20 */  1712, 1712, 1712, 1712, 1712, 1712, 1712,   11,   11,  236,
 /*    30 */   184,  277,  277,  277,  277,  277,  277,   93,  177,  270,
................................................................................
 /*   210 */   531,  531,  531,  531,  531,  531,  531,  531,  531,  531,
 /*   220 */   531,    2,    2,    2,  531,  531,  531,  531,  782,  531,
 /*   230 */   531,  531,  744,  531,  531,  783,  531,  531,  531,  531,
 /*   240 */   531,  531,  531,  531,  419,  682,  327,  370,  370,  370,
 /*   250 */   370, 1029,  327,  327, 1024,  897,  856,  947, 1109,  706,
 /*   260 */   706, 1143, 1109, 1109, 1143,  842,  945, 1118, 1136, 1136,
 /*   270 */  1136,  706,  676,  400, 1047,  694, 1339, 1270, 1270, 1366,
 /*   280 */  1366, 1270, 1305, 1389, 1369, 1278, 1401, 1401, 1401, 1401,
 /*   290 */  1270, 1414, 1278, 1278, 1305, 1389, 1369, 1369, 1278, 1270,
 /*   300 */  1414, 1298, 1385, 1270, 1414, 1432, 1270, 1414, 1270, 1414,
 /*   310 */  1432, 1355, 1355, 1355, 1411, 1432, 1355, 1367, 1355, 1411,
 /*   320 */  1355, 1355, 1432, 1392, 1392, 1432, 1365, 1396, 1365, 1396,
 /*   330 */  1365, 1396, 1365, 1396, 1270, 1372, 1429, 1502, 1390, 1372,
 /*   340 */  1517, 1270, 1397, 1390, 1410, 1413, 1278, 1528, 1532, 1549,
 /*   350 */  1549, 1562, 1562, 1562, 2009, 2009, 2009, 2009, 2009, 2009,
 /*   360 */  2009, 2009, 2009, 2009, 2009, 2009, 2009, 2009, 2009, 2009,
 /*   370 */   570,  345,  686,  748,   50,  740, 1064, 1107,  469,  537,
 /*   380 */  1042, 1146, 1162, 1154, 1201, 1202, 1203, 1208, 1209, 1127,
 /*   390 */  1069, 1196, 1157, 1147, 1226, 1228, 1245,  775,  868, 1246,
 /*   400 */  1247, 1191, 1151, 1585, 1589, 1587, 1456, 1600, 1527, 1601,
 /*   410 */  1595, 1596, 1492, 1484, 1506, 1603, 1495, 1608, 1496, 1614,
 /*   420 */  1635, 1508, 1497, 1521, 1580, 1606, 1505, 1592, 1593, 1597,
 /*   430 */  1598, 1530, 1547, 1619, 1524, 1654, 1651, 1636, 1553, 1510,
 /*   440 */  1594, 1634, 1599, 1588, 1623, 1535, 1564, 1642, 1649, 1652,
 /*   450 */  1552, 1560, 1653, 1609, 1655, 1656, 1657, 1659, 1612, 1658,
 /*   460 */  1660, 1616, 1648, 1664, 1550, 1668, 1538, 1670, 1671, 1669,
 /*   470 */  1673, 1675, 1676, 1678, 1680, 1679, 1574, 1683, 1690, 1610,
 /*   480 */  1682, 1695, 1586, 1698, 1691, 1698, 1693, 1643, 1661, 1646,
 /*   490 */  1686, 1710, 1711, 1714, 1716, 1703, 1715, 1698, 1727, 1728,
 /*   500 */  1729, 1730, 1731, 1732, 1734, 1743, 1736, 1737, 1740, 1744,
 /*   510 */  1738, 1746, 1739, 1645, 1640, 1644, 1647, 1650, 1749, 1751,
 /*   520 */  1772,
};
#define YY_REDUCE_COUNT (369)
#define YY_REDUCE_MIN   (-237)
#define YY_REDUCE_MAX   (1424)
static const short yy_reduce_ofst[] = {
 /*     0 */  -147,  171,  263,  -96,  358, -144, -149, -102,  124, -156,
 /*    10 */   -98,  305,  401,  -57,  209, -237,  245,  -94,  -79,  189,
 /*    20 */   375,  490,  493,  378,  303,  539,  542,  501,  503,  554,
 /*    30 */   415,  526,  546,  557,  587,  593,  595, -234, -234, -234,
 /*    40 */  -234, -234, -234, -234, -234, -234, -234, -234, -234, -234,
 /*    50 */  -234, -234, -234, -234, -234, -234, -234, -234, -234, -234,
................................................................................
 /*   210 */  1112, 1115, 1116, 1117, 1119, 1120, 1121, 1122, 1123, 1124,
 /*   220 */  1125, 1012, 1096, 1097, 1128, 1129, 1130, 1131, 1070, 1135,
 /*   230 */  1137, 1152, 1077, 1153, 1155, 1114, 1156,  304, 1158, 1172,
 /*   240 */  1173, 1174, 1175, 1176, 1089, 1091, 1133, 1098, 1126, 1139,
 /*   250 */  1140, 1070, 1133, 1133, 1170, 1163, 1186, 1103, 1168, 1138,
 /*   260 */  1141, 1110, 1169, 1171, 1132, 1177, 1189, 1194, 1181, 1200,
 /*   270 */  1204, 1166, 1145, 1178, 1187, 1232, 1142, 1231, 1233, 1149,
 /*   280 */  1150, 1238, 1179, 1182, 1212, 1205, 1219, 1220, 1221, 1222,
 /*   290 */  1258, 1266, 1223, 1224, 1206, 1211, 1237, 1239, 1230, 1269,
 /*   300 */  1272, 1195, 1197, 1280, 1284, 1268, 1285, 1289, 1290, 1293,
 /*   310 */  1274, 1286, 1287, 1288, 1282, 1294, 1292, 1297, 1300, 1296,
 /*   320 */  1301, 1306, 1304, 1249, 1250, 1308, 1271, 1275, 1273, 1276,
 /*   330 */  1279, 1281, 1283, 1302, 1334, 1307, 1243, 1267, 1318, 1322,
 /*   340 */  1303, 1371, 1299, 1328, 1332, 1340, 1342, 1384, 1391, 1400,
 /*   350 */  1403, 1407, 1408, 1409, 1311, 1312, 1310, 1405, 1402, 1412,
 /*   360 */  1417, 1420, 1406, 1393, 1395, 1421, 1422, 1423, 1424, 1415,

};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */  1492, 1492, 1492, 1340, 1123, 1229, 1123, 1123, 1123, 1340,
 /*    10 */  1340, 1340, 1123, 1259, 1259, 1391, 1154, 1123, 1123, 1123,
 /*    20 */  1123, 1123, 1123, 1123, 1339, 1123, 1123, 1123, 1123, 1123,
 /*    30 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1265, 1123,
 /*    40 */  1123, 1123, 1123, 1123, 1341, 1342, 1123, 1123, 1123, 1390,
 /*    50 */  1392, 1275, 1274, 1273, 1272, 1373, 1246, 1270, 1263, 1267,
 /*    60 */  1335, 1336, 1334, 1338, 1342, 1341, 1123, 1266, 1306, 1320,
 /*    70 */  1305, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*    80 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*    90 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   100 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   110 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1314, 1319, 1325,
 /*   120 */  1318, 1315, 1308, 1307, 1309, 1310, 1123, 1144, 1193, 1123,
 /*   130 */  1123, 1123, 1123, 1409, 1408, 1123, 1123, 1154, 1311, 1312,
 /*   140 */  1322, 1321, 1398, 1448, 1447, 1123, 1123, 1123, 1123, 1123,
 /*   150 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   160 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   170 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1154, 1150, 1300,
 /*   180 */  1299, 1418, 1150, 1253, 1123, 1404, 1229, 1220, 1123, 1123,
 /*   190 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   200 */  1123, 1395, 1393, 1123, 1355, 1123, 1123, 1123, 1123, 1123,
 /*   210 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   220 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   230 */  1123, 1123, 1225, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   240 */  1123, 1123, 1123, 1442, 1123, 1368, 1207, 1225, 1225, 1225,
 /*   250 */  1225, 1227, 1208, 1206, 1219, 1154, 1130, 1484, 1269, 1248,
 /*   260 */  1248, 1481, 1269, 1269, 1481, 1168, 1462, 1165, 1259, 1259,
 /*   270 */  1259, 1248, 1337, 1226, 1219, 1123, 1484, 1234, 1234, 1483,
 /*   280 */  1483, 1234, 1278, 1284, 1196, 1269, 1202, 1202, 1202, 1202,
 /*   290 */  1234, 1141, 1269, 1269, 1278, 1284, 1196, 1196, 1269, 1234,
 /*   300 */  1141, 1372, 1478, 1234, 1141, 1348, 1234, 1141, 1234, 1141,
 /*   310 */  1348, 1194, 1194, 1194, 1183, 1348, 1194, 1168, 1194, 1183,
 /*   320 */  1194, 1194, 1348, 1352, 1352, 1348, 1252, 1247, 1252, 1247,
 /*   330 */  1252, 1247, 1252, 1247, 1234, 1253, 1417, 1123, 1264, 1253,
 /*   340 */  1343, 1234, 1123, 1264, 1262, 1260, 1269, 1147, 1186, 1445,
 /*   350 */  1445, 1441, 1441, 1441, 1489, 1489, 1404, 1457, 1154, 1154,
 /*   360 */  1154, 1154, 1457, 1170, 1170, 1154, 1154, 1154, 1154, 1457,
 /*   370 */  1123, 1123, 1123, 1123, 1123, 1123, 1452, 1123, 1357, 1238,
 /*   380 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   390 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   400 */  1123, 1123, 1289, 1123, 1126, 1401, 1123, 1123, 1399, 1123,
 /*   410 */  1123, 1123, 1123, 1123, 1123, 1239, 1123, 1123, 1123, 1123,
 /*   420 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   430 */  1123, 1123, 1123, 1123, 1480, 1123, 1123, 1123, 1123, 1123,
 /*   440 */  1123, 1371, 1370, 1123, 1123, 1236, 1123, 1123, 1123, 1123,
 /*   450 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   460 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   470 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   480 */  1123, 1123, 1123, 1261, 1123, 1416, 1123, 1123, 1123, 1123,
 /*   490 */  1123, 1123, 1123, 1430, 1254, 1123, 1123, 1471, 1123, 1123,
 /*   500 */  1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123, 1123,
 /*   510 */  1123, 1123, 1466, 1210, 1291, 1123, 1290, 1294, 1123, 1135,

 /*   520 */  1123,
};
/********** End of lemon-generated parsing tables *****************************/

/* The next table maps tokens (terminal symbols) into fallback tokens.  
** If a construct like the following:
** 
**      %fallback ID X Y Z.
................................................................................
 /* 135 */ "groupby_opt ::= GROUP BY nexprlist",
 /* 136 */ "having_opt ::=",
 /* 137 */ "having_opt ::= HAVING expr",
 /* 138 */ "limit_opt ::=",
 /* 139 */ "limit_opt ::= LIMIT expr",
 /* 140 */ "limit_opt ::= LIMIT expr OFFSET expr",
 /* 141 */ "limit_opt ::= LIMIT expr COMMA expr",
 /* 142 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt",
 /* 143 */ "where_opt ::=",
 /* 144 */ "where_opt ::= WHERE expr",
 /* 145 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist where_opt",
 /* 146 */ "setlist ::= setlist COMMA nm EQ expr",
 /* 147 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
 /* 148 */ "setlist ::= nm EQ expr",
 /* 149 */ "setlist ::= LP idlist RP EQ expr",
 /* 150 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
 /* 151 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES",
 /* 152 */ "upsert ::=",
................................................................................
  {  214,   -3 }, /* (135) groupby_opt ::= GROUP BY nexprlist */
  {  215,    0 }, /* (136) having_opt ::= */
  {  215,   -2 }, /* (137) having_opt ::= HAVING expr */
  {  217,    0 }, /* (138) limit_opt ::= */
  {  217,   -2 }, /* (139) limit_opt ::= LIMIT expr */
  {  217,   -4 }, /* (140) limit_opt ::= LIMIT expr OFFSET expr */
  {  217,   -4 }, /* (141) limit_opt ::= LIMIT expr COMMA expr */
  {  160,   -6 }, /* (142) cmd ::= with DELETE FROM xfullname indexed_opt where_opt */
  {  213,    0 }, /* (143) where_opt ::= */
  {  213,   -2 }, /* (144) where_opt ::= WHERE expr */
  {  160,   -8 }, /* (145) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist where_opt */
  {  233,   -5 }, /* (146) setlist ::= setlist COMMA nm EQ expr */
  {  233,   -7 }, /* (147) setlist ::= setlist COMMA LP idlist RP EQ expr */
  {  233,   -3 }, /* (148) setlist ::= nm EQ expr */
  {  233,   -5 }, /* (149) setlist ::= LP idlist RP EQ expr */
  {  160,   -7 }, /* (150) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
  {  160,   -7 }, /* (151) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */
  {  236,    0 }, /* (152) upsert ::= */
................................................................................
        break;
      case 140: /* limit_opt ::= LIMIT expr OFFSET expr */
{yymsp[-3].minor.yy18 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy18,yymsp[0].minor.yy18);}
        break;
      case 141: /* limit_opt ::= LIMIT expr COMMA expr */
{yymsp[-3].minor.yy18 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy18,yymsp[-2].minor.yy18);}
        break;
      case 142: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt */
{
  sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy135, &yymsp[-1].minor.yy0);
  sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy135,yymsp[0].minor.yy18,0,0);
}
        break;
      case 145: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist where_opt */
{
  sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy135, &yymsp[-3].minor.yy0);
  sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy420,"set list"); 
  sqlite3Update(pParse,yymsp[-4].minor.yy135,yymsp[-1].minor.yy420,yymsp[0].minor.yy18,yymsp[-5].minor.yy70,0,0,0);
}
        break;
      case 146: /* setlist ::= setlist COMMA nm EQ expr */
{
  yymsp[-4].minor.yy420 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy420, yymsp[0].minor.yy18);
  sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy420, &yymsp[-2].minor.yy0, 1);
}
................................................................................
             yyTracePrompt,yyTokenName[yymajor]);
        }
#endif
        yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
        yymajor = YYNOCODE;
      }else{
        while( yypParser->yytos >= yypParser->yystack

            && (yyact = yy_find_reduce_action(
                        yypParser->yytos->stateno,
                        YYERRORSYMBOL)) > YY_MAX_SHIFTREDUCE
        ){
          yy_pop_parser_stack(yypParser);
        }
        if( yypParser->yytos < yypParser->yystack || yymajor==0 ){
          yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
          yy_parse_failed(yypParser);
#ifndef YYNOERRORRECOVERY
................................................................................
      sqlite3 *db = va_arg(ap, sqlite3*);
      db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff);
      break;
    }

    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
    **
    ** If parameter onoff is non-zero, subsequent calls to localtime()
    ** and its variants fail. If onoff is zero, undo this setting.

    */
    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
      break;
    }

    /*   sqlite3_test_control(SQLITE_TESTCTRL_INTERNAL_FUNCS, int onoff);
    **
    ** If parameter onoff is non-zero, internal-use-only SQL functions
    ** are visible to ordinary SQL.  This is useful for testing but is
    ** unsafe because invalid parameters to those internal-use-only functions
    ** can result in crashes or segfaults.
    */
    case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: {
      sqlite3GlobalConfig.bInternalFunctions = va_arg(ap, int);
      break;
    }

    /*   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
................................................................................
    }
    assert( pToken->pSegcsr==0 );
  }

  return rc;
}

#ifndef SQLITE_DISABLE_FTS4_DEFERRED
/*
** This function is called on each phrase after the position lists for
** any deferred tokens have been loaded into memory. It updates the phrases
** current position list to include only those positions that are really
** instances of the phrase (after considering deferred tokens). If this
** means that the phrase does not appear in the current row, doclist.pList
** and doclist.nList are both zeroed.
................................................................................
      }
      sqlite3_free(aPoslist);
    }
  }

  return SQLITE_OK;
}
#endif /* SQLITE_DISABLE_FTS4_DEFERRED */

/*
** Maximum number of tokens a phrase may have to be considered for the
** incremental doclists strategy.
*/
#define MAX_INCR_PHRASE_TOKENS 4

................................................................................
#define JEACH_VALUE   1
#define JEACH_TYPE    2
#define JEACH_ATOM    3
#define JEACH_ID      4
#define JEACH_PARENT  5
#define JEACH_FULLKEY 6
#define JEACH_PATH    7
/* The xBestIndex method assumes that the JSON and ROOT columns are
** the last two columns in the table.  Should this ever changes, be
** sure to update the xBestIndex method. */
#define JEACH_JSON    8
#define JEACH_ROOT    9

  UNUSED_PARAM(pzErr);
  UNUSED_PARAM(argv);
  UNUSED_PARAM(argc);
  UNUSED_PARAM(pAux);
................................................................................
** 1 if the constraint is found, 3 if the constraint and zRoot are found,
** and 0 otherwise.
*/
static int jsonEachBestIndex(
  sqlite3_vtab *tab,
  sqlite3_index_info *pIdxInfo
){
  int i;                     /* Loop counter or computed array index */
  int aIdx[2];               /* Index of constraints for JSON and ROOT */
  int unusableMask = 0;      /* Mask of unusable JSON and ROOT constraints */
  int idxMask = 0;           /* Mask of usable == constraints JSON and ROOT */
  const struct sqlite3_index_constraint *pConstraint;

  /* This implementation assumes that JSON and ROOT are the last two
  ** columns in the table */
  assert( JEACH_ROOT == JEACH_JSON+1 );
  UNUSED_PARAM(tab);
  aIdx[0] = aIdx[1] = -1;
  pConstraint = pIdxInfo->aConstraint;
  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
    int iCol;
    int iMask;
    if( pConstraint->iColumn < JEACH_JSON ) continue;
    iCol = pConstraint->iColumn - JEACH_JSON;
    assert( iCol==0 || iCol==1 );
    iMask = 1 << iCol;
    if( pConstraint->usable==0 ){
      unusableMask |= iMask;
    }else if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){




      aIdx[iCol] = i;
      idxMask |= iMask;
    }
  }

  if( (unusableMask & ~idxMask)!=0 ){
    /* If there are any unusable constraints on JSON or ROOT, then reject
    ** this entire plan */
    return SQLITE_CONSTRAINT;
  }
  if( aIdx[0]<0 ){
    /* No JSON input.  Leave estimatedCost at the huge value that it was
    ** initialized to to discourage the query planner from selecting this
    ** plan. */
    pIdxInfo->idxNum = 0;

  }else{
    pIdxInfo->estimatedCost = 1.0;
    i = aIdx[0];
    pIdxInfo->aConstraintUsage[i].argvIndex = 1;
    pIdxInfo->aConstraintUsage[i].omit = 1;

    if( aIdx[1]<0 ){
      pIdxInfo->idxNum = 1;  /* Only JSON supplied.  Plan 1 */
    }else{
      i = aIdx[1];
      pIdxInfo->aConstraintUsage[i].argvIndex = 2;
      pIdxInfo->aConstraintUsage[i].omit = 1;
      pIdxInfo->idxNum = 3;  /* Both JSON and ROOT are supplied.  Plan 3 */
    }
  }
  return SQLITE_OK;
}

/* Start a search on a new JSON string */
static int jsonEachFilter(
................................................................................
  int argc,
  sqlite3_value **argv
){
  GeoPoly *p = geopolyFuncParam(context, argv[0], 0);
  if( p ){
    if( geopolyArea(p)<0.0 ){
      int ii, jj;
      for(ii=2, jj=p->nVertex*2 - 2; ii<jj; ii+=2, jj-=2){
        GeoCoord t = p->a[ii];
        p->a[ii] = p->a[jj];
        p->a[jj] = t;
        t = p->a[ii+1];
        p->a[ii+1] = p->a[jj+1];
        p->a[jj+1] = t;
      }
................................................................................
** operate on a different database schema, so check for it.
**
** idxNum is normally 0, but will be 1 if a schema=? constraint exists.
*/
static int statBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
  int i;



  /* Look for a valid schema=? constraint.  If found, change the idxNum to
  ** 1 and request the value of that constraint be sent to xFilter.  And
  ** lower the cost estimate to encourage the constrained version to be
  ** used.
  */
  for(i=0; i<pIdxInfo->nConstraint; i++){
    if( pIdxInfo->aConstraint[i].iColumn!=10 ) continue;
    if( pIdxInfo->aConstraint[i].usable==0 ) return SQLITE_CONSTRAINT;
    if( pIdxInfo->aConstraint[i].op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;

    pIdxInfo->idxNum = 1;
    pIdxInfo->estimatedCost = 1.0;
    pIdxInfo->aConstraintUsage[i].argvIndex = 1;
    pIdxInfo->aConstraintUsage[i].omit = 1;
    break;
  }

................................................................................
        if( nLocal<0 ) goto statPageIsCorrupt;
        pCell->nLocal = nLocal;
        assert( nPayload>=(u32)nLocal );
        assert( nLocal<=(nUsable-35) );
        if( nPayload>(u32)nLocal ){
          int j;
          int nOvfl = ((nPayload - nLocal) + nUsable-4 - 1) / (nUsable - 4);
          if( iOff+nLocal>nUsable ) goto statPageIsCorrupt;
          pCell->nLastOvfl = (nPayload-nLocal) - (nOvfl-1) * (nUsable-4);
          pCell->nOvfl = nOvfl;
          pCell->aOvfl = sqlite3_malloc64(sizeof(u32)*nOvfl);
          if( pCell->aOvfl==0 ) return SQLITE_NOMEM_BKPT;
          pCell->aOvfl[0] = sqlite3Get4byte(&aData[iOff+nLocal]);
          for(j=1; j<nOvfl; j++){
            int rc;
................................................................................
  ** unavailable
  */
  for(i=0; i<pIdxInfo->nConstraint; i++){
    struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[i];
    if( p->iColumn!=DBPAGE_COLUMN_SCHEMA ) continue;
    if( p->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
    if( !p->usable ){
      /* No solution. */

      return SQLITE_CONSTRAINT;
    }
    iPlan = 2;
    pIdxInfo->aConstraintUsage[i].argvIndex = 1;
    pIdxInfo->aConstraintUsage[i].omit = 1;
    break;
  }

................................................................................
** of this template is copied straight through into the generate parser
** source file.
**
** The following is the concatenation of all %include directives from the
** input grammar file:
*/
/* #include <stdio.h> */
/* #include <assert.h> */
/************ Begin %include sections from the grammar ************************/

/* #include "fts5Int.h" */
/* #include "fts5parse.h" */

/*
** Disable all error recovery processing in the parser push-down
................................................................................
             fts5yyTracePrompt,fts5yyTokenName[fts5yymajor]);
        }
#endif
        fts5yy_destructor(fts5yypParser, (fts5YYCODETYPE)fts5yymajor, &fts5yyminorunion);
        fts5yymajor = fts5YYNOCODE;
      }else{
        while( fts5yypParser->fts5yytos >= fts5yypParser->fts5yystack

            && (fts5yyact = fts5yy_find_reduce_action(
                        fts5yypParser->fts5yytos->stateno,
                        fts5YYERRORSYMBOL)) > fts5YY_MAX_SHIFTREDUCE
        ){
          fts5yy_pop_parser_stack(fts5yypParser);
        }
        if( fts5yypParser->fts5yytos < fts5yypParser->fts5yystack || fts5yymajor==0 ){
          fts5yy_destructor(fts5yypParser,(fts5YYCODETYPE)fts5yymajor,&fts5yyminorunion);
          fts5yy_parse_failed(fts5yypParser);
#ifndef fts5YYNOERRORRECOVERY
................................................................................
static void fts5SourceIdFunc(
  sqlite3_context *pCtx,          /* Function call context */
  int nArg,                       /* Number of args */
  sqlite3_value **apUnused        /* Function arguments */
){
  assert( nArg==0 );
  UNUSED_PARAM2(nArg, apUnused);
  sqlite3_result_text(pCtx, "fts5: 2018-11-28 11:49:46 b53a9a3dc6b0422a102b245451769b0cd8c0d67090fefabf7cb3a65137a73771", -1, SQLITE_TRANSIENT);
}

/*
** Return true if zName is the extension on one of the shadow tables used
** by this module.
*/
static int fts5ShadowName(const char *zName){
................................................................................
#endif
  return rc;
}
#endif /* SQLITE_CORE */
#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */

/************** End of stmt.c ************************************************/
#if __LINE__!=220527
#undef SQLITE_SOURCE_ID
#define SQLITE_SOURCE_ID      "2018-11-28 11:49:46 b53a9a3dc6b0422a102b245451769b0cd8c0d67090fefabf7cb3a65137a7alt2"
#endif
/* Return the source-id for this library */
SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
/************************** End of sqlite3.c ******************************/

**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
*/
#define SQLITE_VERSION        "3.26.0"
#define SQLITE_VERSION_NUMBER 3026000
#define SQLITE_SOURCE_ID      "2018-11-12 15:20:44 f9755f81b1c0fd29f242dce78a2fba570fa2714d76e93b8563f426a040352513"

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
................................................................................
#define SQLITE_TESTCTRL_PENDING_BYTE            11
#define SQLITE_TESTCTRL_ASSERT                  12
#define SQLITE_TESTCTRL_ALWAYS                  13
#define SQLITE_TESTCTRL_RESERVE                 14
#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
#define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */

#define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
#define SQLITE_TESTCTRL_EXPLAIN_STMT            19  /* NOT USED */
#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
#define SQLITE_TESTCTRL_NEVER_CORRUPT           20
#define SQLITE_TESTCTRL_VDBE_COVERAGE           21
#define SQLITE_TESTCTRL_BYTEORDER               22
#define SQLITE_TESTCTRL_ISINIT                  23

**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
*/
#define SQLITE_VERSION        "3.26.0"
#define SQLITE_VERSION_NUMBER 3026000
#define SQLITE_SOURCE_ID      "2018-11-28 11:49:46 b53a9a3dc6b0422a102b245451769b0cd8c0d67090fefabf7cb3a65137a73771"

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
................................................................................
#define SQLITE_TESTCTRL_PENDING_BYTE            11
#define SQLITE_TESTCTRL_ASSERT                  12
#define SQLITE_TESTCTRL_ALWAYS                  13
#define SQLITE_TESTCTRL_RESERVE                 14
#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
#define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */
#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS      17
#define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
#define SQLITE_TESTCTRL_EXPLAIN_STMT            19  /* NOT USED */
#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
#define SQLITE_TESTCTRL_NEVER_CORRUPT           20
#define SQLITE_TESTCTRL_VDBE_COVERAGE           21
#define SQLITE_TESTCTRL_BYTEORDER               22
#define SQLITE_TESTCTRL_ISINIT                  23