sqllogictest

/******************************************************************************
** This file is an amalgamation of many separate C source files from SQLite
** version 3.6.10.  By combining all the individual C code files into this 
** single large file, the entire code can be compiled as a one translation
** unit.  This allows many compilers to do optimizations that would not be
** possible if the files were compiled separately.  Performance improvements
** of 5% are more are commonly seen when SQLite is compiled as a single
** translation unit.
**
** This file is all you need to compile SQLite.  To use SQLite in other
** programs, you need this file and the "sqlite3.h" header file that defines
** the programming interface to the SQLite library.  (If you do not have 
** the "sqlite3.h" header file at hand, you will find a copy in the first
** 6736 lines past this header comment.)  Additional code files may be
** needed if you want a wrapper to interface SQLite with your choice of
** programming language.  The code for the "sqlite3" command-line shell
** is also in a separate file.  This file contains only code for the core
** SQLite library.
**
** This amalgamation was generated on 2009-01-15 16:00:39 UTC.
*/
#define SQLITE_CORE 1
#define SQLITE_AMALGAMATION 1
#ifndef SQLITE_PRIVATE
# define SQLITE_PRIVATE static
#endif
#ifndef SQLITE_API

**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** Internal interface definitions for SQLite.
**
** @(#) $Id: sqliteInt.h,v 1.824 2009/01/14 23:03:41 drh Exp $
*/
#ifndef _SQLITEINT_H_
#define _SQLITEINT_H_

/*
** Include the configuration header output by 'configure' if we're using the
** autoconf-based build

** condition/decision coverage is inadequate.  For example, testcase()
** can be used to make sure boundary values are tested.  For
** bitmask tests, testcase() can be used to make sure each bit
** is significant and used at least once.  On switch statements
** where multiple cases go to the same block of code, testcase()
** can insure that all cases are evaluated.
**



*/
#ifdef SQLITE_COVERAGE_TEST
SQLITE_PRIVATE   void sqlite3Coverage(int);
# define testcase(X)  if( X ){ sqlite3Coverage(__LINE__); }

#else
# define testcase(X)
#endif

/*
** The TESTONLY macro is used to enclose variable declarations or
** other bits of code that are needed to support the arguments
** within testcase() and assert() macros.
*/
#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)
# define TESTONLY(X)  X
#else
# define TESTONLY(X)
#endif

/*
** The ALWAYS and NEVER macros surround boolean expressions which 
** are intended to always be true or false, respectively.  Such
** expressions could be omitted from the code completely.  But they

**          evaluate to a string literal that is the SQLite version
**          with which the header file is associated.
**
** {H10014} The SQLITE_VERSION_NUMBER #define shall resolve to an integer
**          with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z
**          are the major version, minor version, and release number.
*/
#define SQLITE_VERSION         "3.6.10"
#define SQLITE_VERSION_NUMBER  3006010

/*
** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100>
** KEYWORDS: sqlite3_version
**
** These features provide the same information as the [SQLITE_VERSION]
** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated

** This header file (together with is companion C source-code file
** "os.c") attempt to abstract the underlying operating system so that
** the SQLite library will work on both POSIX and windows systems.
**
** This header file is #include-ed by sqliteInt.h and thus ends up
** being included by every source file.
**
** $Id: os.h,v 1.107 2009/01/14 23:03:41 drh Exp $
*/
#ifndef _SQLITE_OS_H_
#define _SQLITE_OS_H_

/*
** Figure out if we are dealing with Unix, Windows, or some other
** operating system.  After the following block of preprocess macros,

SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size);
SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file*, int);
SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file*, i64 *pSize);
SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file*, int);
SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file*, int);
SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut);
SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*);
#define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0
SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id);
SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id);

/* 
** Functions for accessing sqlite3_vfs methods 
*/
SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *);

**   *  Definitions of sqlite3_io_methods objects for all locking
**      methods plus "finder" functions for each locking method.
**   *  sqlite3_vfs method implementations.
**   *  Locking primitives for the proxy uber-locking-method. (MacOSX only)
**   *  Definitions of sqlite3_vfs objects for all locking methods
**      plus implementations of sqlite3_os_init() and sqlite3_os_end().
**
** $Id: os_unix.c,v 1.237 2009/01/15 04:30:03 drh Exp $
*/
#if SQLITE_OS_UNIX              /* This file is used on unix only */

/*
** There are various methods for file locking used for concurrency
** control:
**

#if SQLITE_THREADSAFE && defined(__linux__)
  pthread_t tid;                   /* The thread that "owns" this unixFile */
#endif
#if OS_VXWORKS
  int isDelete;                    /* Delete on close if true */
  struct vxworksFileId *pId;       /* Unique file ID */
#endif
#ifndef NDEBUG
  /* The next group of variables are used to track whether or not the
  ** transaction counter in bytes 24-27 of database files are updated
  ** whenever any part of the database changes.  An assertion fault will
  ** occur if a file is updated without also updating the transaction
  ** counter.  This test is made to avoid new problems similar to the
  ** one described by ticket #3584. 
  */
  unsigned char transCntrChng;   /* True if the transaction counter changed */
  unsigned char dbUpdate;        /* True if any part of database file changed */
  unsigned char inNormalWrite;   /* True if in a normal write operation */
#endif
#ifdef SQLITE_TEST
  /* In test mode, increase the size of this structure a bit so that 
  ** it is larger than the struct CrashFile defined in test6.c.
  */
  char aPadding[32];
#endif
};

      rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
      if( IS_LOCK_ERROR(rc) ){
        pFile->lastErrno = tErrno;
      }
    }
  }
  

#ifndef NDEBUG
  /* Set up the transaction-counter change checking flags when
  ** transitioning from a SHARED to a RESERVED lock.  The change
  ** from SHARED to RESERVED marks the beginning of a normal
  ** write operation (not a hot journal rollback).
  */
  if( rc==SQLITE_OK
   && pFile->locktype<=SHARED_LOCK
   && locktype==RESERVED_LOCK
  ){
    pFile->transCntrChng = 0;
    pFile->dbUpdate = 0;
    pFile->inNormalWrite = 1;
  }
#endif


  if( rc==SQLITE_OK ){
    pFile->locktype = locktype;
    pLock->locktype = locktype;
  }else if( locktype==EXCLUSIVE_LOCK ){
    pFile->locktype = PENDING_LOCK;
    pLock->locktype = PENDING_LOCK;
  }

  pLock = pFile->pLock;
  assert( pLock->cnt!=0 );
  if( pFile->locktype>SHARED_LOCK ){
    assert( pLock->locktype==pFile->locktype );
    SimulateIOErrorBenign(1);
    SimulateIOError( h=(-1) )
    SimulateIOErrorBenign(0);

#ifndef NDEBUG
    /* When reducing a lock such that other processes can start
    ** reading the database file again, make sure that the
    ** transaction counter was updated if any part of the database
    ** file changed.  If the transaction counter is not updated,
    ** other connections to the same file might not realize that
    ** the file has changed and hence might not know to flush their
    ** cache.  The use of a stale cache can lead to database corruption.
    */
    assert( pFile->inNormalWrite==0
         || pFile->dbUpdate==0
         || pFile->transCntrChng==1 );
    pFile->inNormalWrite = 0;
#endif


    if( locktype==SHARED_LOCK ){
      lock.l_type = F_RDLCK;
      lock.l_whence = SEEK_SET;
      lock.l_start = SHARED_FIRST;
      lock.l_len = SHARED_SIZE;
      if( fcntl(h, F_SETLK, &lock)==(-1) ){
        int tErrno = errno;

  const void *pBuf, 
  int amt,
  sqlite3_int64 offset 
){
  int wrote = 0;
  assert( id );
  assert( amt>0 );

#ifndef NDEBUG
  /* If we are doing a normal write to a database file (as opposed to
  ** doing a hot-journal rollback or a write to some file other than a
  ** normal database file) then record the fact that the database
  ** has changed.  If the transaction counter is modified, record that
  ** fact too.
  */
  if( ((unixFile*)id)->inNormalWrite ){
    unixFile *pFile = (unixFile*)id;
    pFile->dbUpdate = 1;  /* The database has been modified */
    if( offset<=24 && offset+amt>=27 ){
      char oldCntr[4];
      SimulateIOErrorBenign(1);
      seekAndRead(pFile, 24, oldCntr, 4);
      SimulateIOErrorBenign(0);
      if( memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
        pFile->transCntrChng = 1;  /* The transaction counter has changed */
      }
    }
  }
#endif

  while( amt>0 && (wrote = seekAndWrite((unixFile*)id, offset, pBuf, amt))>0 ){
    amt -= wrote;
    offset += wrote;
    pBuf = &((char*)pBuf)[wrote];
  }
  SimulateIOError(( wrote=(-1), amt=1 ));
  SimulateDiskfullError(( wrote=0, amt=1 ));

  ** the fcntl call every time sync is called.
  */
  if( rc ) rc = fsync(fd);

#else 
  if( dataOnly ){
    rc = fdatasync(fd);
#if OS_VXWORKS
    if( rc==-1 && errno==ENOTSUP ){
      rc = fsync(fd);
    }
#endif
  }else{
    rc = fsync(fd);
  }
#endif /* ifdef SQLITE_NO_SYNC elif HAVE_FULLFSYNC */

  if( OS_VXWORKS && rc!= -1 ){
    rc = 0;

      *(int*)pArg = ((unixFile*)id)->locktype;
      return SQLITE_OK;
    }
    case SQLITE_LAST_ERRNO: {
      *(int*)pArg = ((unixFile*)id)->lastErrno;
      return SQLITE_OK;
    }
#ifndef NDEBUG
    /* The pager calls this method to signal that it has done
    ** a rollback and that the database is therefore unchanged and
    ** it hence it is OK for the transaction change counter to be
    ** unchanged.
    */
    case SQLITE_FCNTL_DB_UNCHANGED: {
      ((unixFile*)id)->dbUpdate = 0;
      return SQLITE_OK;
    }
#endif
#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
    case SQLITE_SET_LOCKPROXYFILE:
    case SQLITE_GET_LOCKPROXYFILE: {
      return proxyFileControl(id,op,pArg);
    }
#endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */
  }

** The pager is used to access a database disk file.  It implements
** atomic commit and rollback through the use of a journal file that
** is separate from the database file.  The pager also implements file
** locking to prevent two processes from writing the same database
** file simultaneously, or one process from reading the database while
** another is writing.
**
** @(#) $Id: pager.c,v 1.551 2009/01/14 23:03:41 drh Exp $
*/
#ifndef SQLITE_OMIT_DISKIO

/*
** Macros for troubleshooting.  Normally turned off
*/
#if 0

  }else{
    assert( pPager->pInJournal==0 );
  }

  if( !pPager->exclusiveMode ){
    rc2 = osUnlock(pPager->fd, SHARED_LOCK);
    pPager->state = PAGER_SHARED;
    pPager->changeCountDone = 0;
  }else if( pPager->state==PAGER_SYNCED ){
    pPager->state = PAGER_EXCLUSIVE;
  }
  pPager->dbOrigSize = 0;
  pPager->setMaster = 0;
  pPager->needSync = 0;
  /* lruListSetFirstSynced(pPager); */

      }
    }
  }
  /*NOTREACHED*/
  assert( 0 );

end_playback:
  /* Following a rollback, the database file should be back in its original
  ** state prior to the start of the transaction, so invoke the
  ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
  ** assertion that the transaction counter was modified.
  */
  assert(
    pPager->fd->pMethods==0 ||
    sqlite3OsFileControl(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0)>=SQLITE_OK
  );

  if( rc==SQLITE_OK ){
    zMaster = pPager->pTmpSpace;
    rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
  }
  if( rc==SQLITE_OK ){
    rc = pager_end_transaction(pPager, zMaster[0]!='\0');
  }

**  yy_shift_ofst[]    For each state, the offset into yy_action for
**                     shifting terminals.
**  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.
*/
static const YYACTIONTYPE yy_action[] = {
 /*     0 */   304,  930,  120,  609,    1,  178,  214,  436,   62,   62,
 /*    10 */    62,   62,  216,   64,   64,   64,   64,   65,   65,   66,
 /*    20 */    66,   66,   67,  216,  406,  403,  443,  449,   69,   64,
 /*    30 */    64,   64,   64,   65,   65,   66,   66,   66,   67,  216,
 /*    40 */   469,  467,  336,  174,   61,   60,  309,  453,  454,  450,
 /*    50 */   450,   63,   63,   62,   62,   62,   62,  200,   64,   64,
 /*    60 */    64,   64,   65,   65,   66,   66,   66,   67,  216,  304,
 /*    70 */   510,  312,  436,  509,  438,   83,   64,   64,   64,   64,
 /*    80 */    65,   65,   66,   66,   66,   67,  216,   65,   65,   66,
 /*    90 */    66,   66,   67,  216,  511,  443,  449,  325,  408,   59,
 /*   100 */   465,  218,   57,  213,  411,  496,  428,  440,  440,  440,
 /*   110 */   206,   67,  216,   61,   60,  309,  453,  454,  450,  450,
 /*   120 */    63,   63,   62,   62,   62,   62,  552,   64,   64,   64,
 /*   130 */    64,   65,   65,   66,   66,   66,   67,  216,  304,  228,
 /*   140 */   186,  469,  544,  312,  433,  170,  114,  256,  357,  261,
 /*   150 */   358,  181,  425,   20,  426,  542,  153,   85,  265,  465,
 /*   160 */   218,  150,  151,  539,  443,  449,   95,  311,  394,  412,
 /*   170 */   413,  510,  276,  427,  436,  438,  152,  553,  545,  589,
 /*   180 */   590,  539,   61,   60,  309,  453,  454,  450,  450,   63,
 /*   190 */    63,   62,   62,   62,   62,  402,   64,   64,   64,   64,
 /*   200 */    65,   65,   66,   66,   66,   67,  216,  304,  440,  440,
 /*   210 */   440,  228,  109,  411,  399,  523,  593,  330,  114,  256,
 /*   220 */   357,  261,  358,  181,  187,  330,  485,  359,  362,  363,
 /*   230 */   265,  593,  241,  443,  449,  592,  591,  248,  364,  436,
 /*   240 */   432,   35,  492,   66,   66,   66,   67,  216,  432,   42,
 /*   250 */   592,   61,   60,  309,  453,  454,  450,  450,   63,   63,
 /*   260 */    62,   62,   62,   62,  401,   64,   64,   64,   64,   65,
 /*   270 */    65,   66,   66,   66,   67,  216,  304,  570,  412,  413,
 /*   280 */   187,  501,  344,  359,  362,  363,  215,  354,  346,  221,
 /*   290 */   330,  341,  330,   56,  364,  569,  588,  217,   68,  156,
 /*   300 */    70,  155,  443,  449,   68,  187,   70,  155,  359,  362,
 /*   310 */   363,  397,  217,  432,   35,  432,   36,  148,  569,  364,
 /*   320 */    61,   60,  309,  453,  454,  450,  450,   63,   63,   62,
 /*   330 */    62,   62,   62,  433,   64,   64,   64,   64,   65,   65,
 /*   340 */    66,   66,   66,   67,  216,  387,  282,  281,  330,  304,
 /*   350 */   474,   68,  480,   70,  155,  344,  214,  154,  299,  330,
 /*   360 */   343,  467,  543,  174,  384,  475,  257,  247,  387,  282,
 /*   370 */   281,  432,   28,  411,  160,  443,  449,  258,  476,  214,
 /*   380 */   516,  496,  432,   42,  198,  492,   68,  162,   70,  155,
 /*   390 */   517,  433,   78,   61,   60,  309,  453,  454,  450,  450,
 /*   400 */    63,   63,   62,   62,   62,   62,  595,   64,   64,   64,
 /*   410 */    64,   65,   65,   66,   66,   66,   67,  216,  433,  367,
 /*   420 */   349,  433,  304,  220,  222,  544,  505,  330,  465,  330,
 /*   430 */   230,  330,  240,  163,  161,  554,   20,  431,  412,  413,
 /*   440 */     2,  430,  385,  375,  411,  198,  182,  249,  443,  449,
 /*   450 */   432,   35,  432,   50,  432,   50,  310,  460,  461,   17,
 /*   460 */   207,  335,  460,  461,  388,   81,   61,   60,  309,  453,
 /*   470 */   454,  450,  450,   63,   63,   62,   62,   62,   62,  433,
 /*   480 */    64,   64,   64,   64,   65,   65,   66,   66,   66,   67,
 /*   490 */   216,  304,  348,  504,  433,  508,  531,  486,  320,  353,
 /*   500 */   321,  306,  457,  385,   23,  331,  265,  470,  411,  412,
 /*   510 */   413,  444,  445,  551,  526,  307,  532,  443,  449,  217,
 /*   520 */   550,  496,  432,    3,  217,  381,  607,  921,  333,  921,
 /*   530 */   456,  456,  447,  448,  276,   61,   60,  309,  453,  454,
 /*   540 */   450,  450,   63,   63,   62,   62,   62,   62,  410,   64,
 /*   550 */    64,   64,   64,   65,   65,   66,   66,   66,   67,  216,
 /*   560 */   304,  446,  607,  920,  525,  920,  604,  264,  314,  474,
 /*   570 */   411,  123,  411,  412,  413,  124,  277,  487,  234,  333,
 /*   580 */   411,  456,  456,  319,  475,  411,  443,  449,  333,  377,
 /*   590 */   456,  456,  286,  333,  380,  456,  456,  476,  178,  340,
 /*   600 */   436,  420,  604,  315,   61,   60,  309,  453,  454,  450,
 /*   610 */   450,   63,   63,   62,   62,   62,   62,  330,   64,   64,
 /*   620 */    64,   64,   65,   65,   66,   66,   66,   67,  216,  304,
 /*   630 */   289,    5,  287,  268,  466,  412,  413,  412,  413,  396,
 /*   640 */   432,   29,  503,  330,  159,  412,  413,  610,  406,  403,
 /*   650 */   412,  413,  414,  415,  416,  443,  449,  333,  214,  456,
 /*   660 */   456,  488,  276,  489,   21,  436,  432,   24,  436,  487,
 /*   670 */   514,  515,  395,   61,   60,  309,  453,  454,  450,  450,
 /*   680 */    63,   63,   62,   62,   62,   62,  330,   64,   64,   64,
 /*   690 */    64,   65,   65,   66,   66,   66,   67,  216,  304,  560,
 /*   700 */   374,  560,  352,   94,  578,  330,  567,  515,  330,  432,
 /*   710 */    33,  330,  288,  330,  562,  330,  544,  330,  561,  183,
 /*   720 */   184,  185,  603,  303,  443,  449,  600,   20,  432,   54,
 /*   730 */   376,  432,   53,  436,  432,   99,  432,   97,  432,  102,
 /*   740 */   432,  103,   61,   60,  309,  453,  454,  450,  450,   63,
 /*   750 */    63,   62,   62,   62,   62,  330,   64,   64,   64,   64,
 /*   760 */    65,   65,   66,   66,   66,   67,  216,  304,  330,  405,
 /*   770 */     1,  202,  330,  512,  330,  214,  330,  171,  432,  108,
 /*   780 */   330,  421,  429,  330,  487,  342,  330,  384,   19,  386,
 /*   790 */   145,  432,  110,  443,  449,  432,   16,  432,  100,  432,
 /*   800 */    34,  351,  270,  432,   98,  433,  432,   25,  276,  432,
 /*   810 */    55,   61,   60,  309,  453,  454,  450,  450,   63,   63,
 /*   820 */    62,   62,   62,   62,  330,   64,   64,   64,   64,   65,
 /*   830 */    65,   66,   66,   66,   67,  216,  304,  330,  323,  119,
 /*   840 */   274,  330,  272,  330,  355,  330,  422,  432,  111,  330,
 /*   850 */   580,  159,  115,  233,  330,  177,  161,  439,  463,  463,
 /*   860 */   432,  112,  443,  449,  432,  113,  432,   26,  432,   37,
 /*   870 */   649,  431,  432,   38,  492,  430,  487,  432,   27,  264,
 /*   880 */    61,   71,  309,  453,  454,  450,  450,   63,   63,   62,
 /*   890 */    62,   62,   62,  330,   64,   64,   64,   64,   65,   65,
 /*   900 */    66,   66,   66,   67,  216,  304,  330,  264,  264,  528,
 /*   910 */   330,  157,  330,  252,  330,  229,  432,   39,  330,  482,
 /*   920 */   332,  478,   77,  330,   79,  330,  483,  520,  521,  432,
 /*   930 */    40,  443,  449,  432,   41,  432,   43,  432,   44,  492,
 /*   940 */   491,  432,   45,  316,  317,  433,  432,   30,  432,   31,
 /*   950 */    60,  309,  453,  454,  450,  450,   63,   63,   62,   62,
 /*   960 */    62,   62,  330,   64,   64,   64,   64,   65,   65,   66,
 /*   970 */    66,   66,   67,  216,  304,  330,  264,  564,  254,  330,
 /*   980 */   458,  330,   22,  330,  495,  432,   46,  330,  494,  535,
 /*   990 */   179,  186,  330,  267,  330,  186,  451,  497,  432,   47,
 /*  1000 */   443,  449,  432,   48,  432,   49,  432,   32,  182,  262,
 /*  1010 */   432,   10,  318,  276,  389,  432,   51,  432,   52,  276,
 /*  1020 */   309,  453,  454,  450,  450,   63,   63,   62,   62,   62,
 /*  1030 */    62,  276,   64,   64,   64,   64,   65,   65,   66,   66,
 /*  1040 */    66,   67,  216,  165,  276,  276,  189,  192,  235,  236,
 /*  1050 */   237,  168,  239,  566,  105,  581,   18,  530,  529,   73,
 /*  1060 */   337,  582,    4,  306,  605,  527,  308,  211,  366,  294,
 /*  1070 */   186,  263,  533,  231,  334,  565,  295,  186,  534,  546,
 /*  1080 */   433,  433,  573,  574,  179,   92,  232,  292,  209,  269,
 /*  1090 */   569,  339,  271,  853,  208,  273,  275,  210,  585,  195,
 /*  1100 */    92,  469,  371,  606,  602,    8,  302,  423,  280,  379,
 /*  1110 */   382,  383,  147,  242,  283,  437,  462,  284,  285,  577,
 /*  1120 */   338,   76,   75,  587,  293,  296,  297,  599,  481,  464,
 /*  1130 */    74,  328,  329,  250,  526,  438,  572,  166,  290,  393,
 /*  1140 */   392,  291,  281,  409,  537,  584,  305,  484,  259,  540,
 /*  1150 */   417,  214,  418,  214,  536,  326,  538,  419,  361,  167,
 /*  1160 */    73,  337,  169,    4,    7,  327,  347,  308,  440,  440,
 /*  1170 */   440,  441,  442,   11,   85,  334,  398,   84,  434,  345,
 /*  1180 */   243,   58,  244,   73,  337,   80,    4,  245,  435,  246,
 /*  1190 */   308,  176,  339,  479,   86,  121,  356,  350,  334,  493,
 /*  1200 */   251,  253,  469,  499,  255,  513,  500,  518,  313,  519,
 /*  1210 */   260,  523,  125,  522,  226,  339,  219,  524,  368,  190,
 /*  1220 */   191,  300,   76,   75,  502,  469,  225,  227,  547,  541,
 /*  1230 */   548,   74,  328,  329,  301,  555,  438,  549,  370,  193,
 /*  1240 */   372,  194,  557,   89,  196,   76,   75,  278,  378,  117,
 /*  1250 */   558,  568,  133,  390,   74,  328,  329,  199,  391,  438,
 /*  1260 */   322,  134,  135,  136,  575,  143,  583,  596,  139,  440,
 /*  1270 */   440,  440,  441,  442,   11,  597,  598,  601,  137,  142,
 /*  1280 */   101,  224,  104,  407,  238,  424,  650,  651,   93,  172,
 /*  1290 */    96,  173,  440,  440,  440,  441,  442,   11,  452,  455,
 /*  1300 */    72,  471,  459,  468,  472,  144,  158,    6,  473,  490,
 /*  1310 */   107,  175,  477,   82,   13,  122,   12,  180,  506,  118,
 /*  1320 */   498,  164,  507,  324,  223,   87,  126,  116,  266,  127,
 /*  1330 */    88,  128,  188,  258,  360,  369,  146,  556,  129,  373,
 /*  1340 */   179,  365,  279,  197,  131,  130,  563,    9,  571,  132,
 /*  1350 */   559,  201,   14,  576,  203,  204,  205,  579,  140,  138,
 /*  1360 */   141,   15,  586,  594,  212,  106,  400,  298,  149,  404,
 /*  1370 */   931,  608,   90,   91,
};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */    19,  142,  143,  144,  145,   24,  113,   26,   72,   73,
 /*    10 */    74,   75,   87,   77,   78,   79,   80,   81,   82,   83,
 /*    20 */    84,   85,   86,   87,    1,    2,   45,   46,   76,   77,
 /*    30 */    78,   79,   80,   81,   82,   83,   84,   85,   86,   87,
 /*    40 */    61,  165,  166,  167,   63,   64,   65,   66,   67,   68,
 /*    50 */    69,   70,   71,   72,   73,   74,   75,   25,   77,   78,
 /*    60 */    79,   80,   81,   82,   83,   84,   85,   86,   87,   19,
 /*    70 */    91,   19,   91,  173,   95,   25,   77,   78,   79,   80,
 /*    80 */    81,   82,   83,   84,   85,   86,   87,   81,   82,   83,
 /*    90 */    84,   85,   86,   87,  173,   45,   46,  146,  147,   49,
 /*   100 */    81,   82,   22,  152,   26,  150,   26,  128,  129,  130,
 /*   110 */   159,   86,   87,   63,   64,   65,   66,   67,   68,   69,
 /*   120 */    70,   71,   72,   73,   74,   75,  185,   77,   78,   79,
 /*   130 */    80,   81,   82,   83,   84,   85,   86,   87,   19,   87,
 /*   140 */    25,   61,  150,   19,  193,   93,   94,   95,   96,   97,
 /*   150 */    98,   99,  160,  161,  171,  172,   25,  125,  106,   81,
 /*   160 */    82,   81,   82,  180,   45,   46,   47,  212,  217,   91,
 /*   170 */    92,   91,  150,  172,   26,   95,  184,  185,  185,  101,
 /*   180 */   102,  180,   63,   64,   65,   66,   67,   68,   69,   70,
 /*   190 */    71,   72,   73,   74,   75,  244,   77,   78,   79,   80,
 /*   200 */    81,   82,   83,   84,   85,   86,   87,   19,  128,  129,
 /*   210 */   130,   87,   24,   26,  192,  100,  150,  150,   94,   95,
 /*   220 */    96,   97,   98,   99,   93,  150,   25,   96,   97,   98,
 /*   230 */   106,  150,  194,   45,   46,  169,  170,  150,  107,   91,
 /*   240 */   173,  174,  165,   83,   84,   85,   86,   87,  173,  174,
 /*   250 */   169,   63,   64,   65,   66,   67,   68,   69,   70,   71,
 /*   260 */    72,   73,   74,   75,  242,   77,   78,   79,   80,   81,
 /*   270 */    82,   83,   84,   85,   86,   87,   19,   11,   91,   92,
 /*   280 */    93,  204,  215,   96,   97,   98,  196,  220,  213,  214,
 /*   290 */   150,  190,  150,  203,  107,   52,  230,  231,  221,  159,
 /*   300 */   223,  224,   45,   46,  221,   93,  223,  224,   96,   97,
 /*   310 */    98,  230,  231,  173,  174,  173,  174,  116,   52,  107,
 /*   320 */    63,   64,   65,   66,   67,   68,   69,   70,   71,   72,
 /*   330 */    73,   74,   75,  193,   77,   78,   79,   80,   81,   82,
 /*   340 */    83,   84,   85,   86,   87,  102,  103,  104,  150,   19,
 /*   350 */    12,  221,  222,  223,  224,  215,  113,  159,  162,  150,
 /*   360 */   220,  165,  166,  167,  150,   27,   95,  225,  102,  103,
 /*   370 */   104,  173,  174,   26,  150,   45,   46,  106,   40,  113,
 /*   380 */    42,  150,  173,  174,  159,  165,  221,  159,  223,  224,
 /*   390 */    52,  193,  135,   63,   64,   65,   66,   67,   68,   69,
 /*   400 */    70,   71,   72,   73,   74,   75,  241,   77,   78,   79,
 /*   410 */    80,   81,   82,   83,   84,   85,   86,   87,  193,   19,
 /*   420 */   150,  193,   19,  214,  204,  150,   23,  150,   81,  150,
 /*   430 */   216,  150,  157,  205,  206,  160,  161,  110,   91,   92,
 /*   440 */    22,  114,  217,  212,   26,  159,   46,  150,   45,   46,
 /*   450 */   173,  174,  173,  174,  173,  174,  168,  169,  170,  234,
 /*   460 */   159,  168,  169,  170,  239,  135,   63,   64,   65,   66,
 /*   470 */    67,   68,   69,   70,   71,   72,   73,   74,   75,  193,
 /*   480 */    77,   78,   79,   80,   81,   82,   83,   84,   85,   86,
 /*   490 */    87,   19,  215,   23,  193,   23,   33,  207,  219,  150,
 /*   500 */   219,  101,   23,  217,   22,  150,  106,   23,   26,   91,
 /*   510 */    92,   45,   46,  180,  181,  154,   53,   45,   46,  231,
 /*   520 */   187,  150,  173,  174,  231,  239,   22,   23,  109,   25,
 /*   530 */   111,  112,   66,   67,  150,   63,   64,   65,   66,   67,
 /*   540 */    68,   69,   70,   71,   72,   73,   74,   75,  150,   77,
 /*   550 */    78,   79,   80,   81,   82,   83,   84,   85,   86,   87,
 /*   560 */    19,   95,   22,   23,   23,   25,   62,  150,  105,   12,
 /*   570 */    26,   23,   26,   91,   92,   23,  192,   25,  148,  109,
 /*   580 */    26,  111,  112,  212,   27,   26,   45,   46,  109,  228,
 /*   590 */   111,  112,   17,  109,  233,  111,  112,   40,   24,   42,
 /*   600 */    26,  150,   62,  186,   63,   64,   65,   66,   67,   68,
 /*   610 */    69,   70,   71,   72,   73,   74,   75,  150,   77,   78,
 /*   620 */    79,   80,   81,   82,   83,   84,   85,   86,   87,   19,
 /*   630 */    55,  195,   57,   23,  165,   91,   92,   91,   92,   94,
 /*   640 */   173,  174,   83,  150,   92,   91,   92,    0,    1,    2,
 /*   650 */    91,   92,    7,    8,    9,   45,   46,  109,  113,  111,
 /*   660 */   112,  117,  150,  117,   22,   91,  173,  174,   26,  117,
 /*   670 */   189,  190,  127,   63,   64,   65,   66,   67,   68,   69,
 /*   680 */    70,   71,   72,   73,   74,   75,  150,   77,   78,   79,
 /*   690 */    80,   81,   82,   83,   84,   85,   86,   87,   19,  102,
 /*   700 */   103,  104,   19,   24,  192,  150,  189,  190,  150,  173,
 /*   710 */   174,  150,  137,  150,   28,  150,  150,  150,   32,  102,
 /*   720 */   103,  104,  247,  248,   45,   46,  160,  161,  173,  174,
 /*   730 */    44,  173,  174,   91,  173,  174,  173,  174,  173,  174,
 /*   740 */   173,  174,   63,   64,   65,   66,   67,   68,   69,   70,
 /*   750 */    71,   72,   73,   74,   75,  150,   77,   78,   79,   80,
 /*   760 */    81,   82,   83,   84,   85,   86,   87,   19,  150,  144,
 /*   770 */   145,  159,  150,  164,  150,  113,  150,   22,  173,  174,
 /*   780 */   150,  150,  173,  150,   25,  150,  150,  150,   22,  127,
 /*   790 */    24,  173,  174,   45,   46,  173,  174,  173,  174,  173,
 /*   800 */   174,  118,   17,  173,  174,  193,  173,  174,  150,  173,
 /*   810 */   174,   63,   64,   65,   66,   67,   68,   69,   70,   71,
 /*   820 */    72,   73,   74,   75,  150,   77,   78,   79,   80,   81,
 /*   830 */    82,   83,   84,   85,   86,   87,   19,  150,  245,  246,
 /*   840 */    55,  150,   57,  150,   83,  150,  150,  173,  174,  150,
 /*   850 */   192,   92,  150,  216,  150,  205,  206,  150,  128,  129,
 /*   860 */   173,  174,   45,   46,  173,  174,  173,  174,  173,  174,
 /*   870 */   115,  110,  173,  174,  165,  114,  117,  173,  174,  150,
 /*   880 */    63,   64,   65,   66,   67,   68,   69,   70,   71,   72,
 /*   890 */    73,   74,   75,  150,   77,   78,   79,   80,   81,   82,
 /*   900 */    83,   84,   85,   86,   87,   19,  150,  150,  150,  182,
 /*   910 */   150,  159,  150,  204,  150,  186,  173,  174,  150,   30,
 /*   920 */    19,  150,  134,  150,  136,  150,   37,    7,    8,  173,
 /*   930 */   174,   45,   46,  173,  174,  173,  174,  173,  174,  165,
 /*   940 */   150,  173,  174,  186,  186,  193,  173,  174,  173,  174,
 /*   950 */    64,   65,   66,   67,   68,   69,   70,   71,   72,   73,
 /*   960 */    74,   75,  150,   77,   78,   79,   80,   81,   82,   83,
 /*   970 */    84,   85,   86,   87,   19,  150,  150,   21,  204,  150,
 /*   980 */    23,  150,   25,  150,  150,  173,  174,  150,   23,   23,
 /*   990 */    25,   25,  150,   23,  150,   25,   95,  150,  173,  174,
 /*  1000 */    45,   46,  173,  174,  173,  174,  173,  174,   46,  150,
 /*  1010 */   173,  174,  186,  150,   58,  173,  174,  173,  174,  150,
 /*  1020 */    65,   66,   67,   68,   69,   70,   71,   72,   73,   74,
 /*  1030 */    75,  150,   77,   78,   79,   80,   81,   82,   83,   84,
 /*  1040 */    85,   86,   87,    5,  150,  150,  159,  159,   10,   11,
 /*  1050 */    12,   13,   14,   97,   16,  192,   22,   94,   95,   19,
 /*  1060 */    20,  192,   22,  101,   23,  150,   26,   29,   23,   31,
 /*  1070 */    25,  150,  182,  192,   34,   23,   38,   25,  182,  150,
 /*  1080 */   193,  193,   23,   23,   25,   25,  192,  192,   50,  150,
 /*  1090 */    52,   51,  150,  137,   56,  150,  150,   59,   23,  235,
 /*  1100 */    25,   61,  236,   62,   23,   71,   25,  153,  150,  150,
 /*  1110 */   150,  150,  195,  197,  150,  165,  232,  150,  150,  150,
 /*  1120 */   227,   81,   82,  150,  150,  150,  150,  150,  176,  232,
 /*  1130 */    90,   91,   92,  208,  181,   95,  198,    6,  208,  208,
 /*  1140 */   102,  103,  104,  149,  165,  198,  108,  176,  176,  165,
 /*  1150 */   149,  113,  149,  113,  176,  149,  176,   13,  177,  151,
 /*  1160 */    19,   20,  151,   22,   25,  158,  122,   26,  128,  129,
 /*  1170 */   130,  131,  132,  133,  125,   34,  138,  123,  193,  121,
 /*  1180 */   198,  124,  199,   19,   20,  134,   22,  200,  202,  201,
 /*  1190 */    26,  115,   51,  156,  101,  156,  101,  120,   34,  210,
 /*  1200 */   209,  209,   61,  210,  209,  175,  210,  175,   43,  183,
 /*  1210 */   175,  100,   22,  177,   87,   51,  226,  175,   18,  155,
 /*  1220 */   155,  178,   81,   82,   83,   61,  229,  229,  175,  183,
 /*  1230 */   175,   90,   91,   92,  178,  156,   95,  175,  156,  155,
 /*  1240 */    41,  156,  156,  134,  155,   81,   82,  237,  156,   63,
 /*  1250 */   238,  188,   22,  156,   90,   91,   92,  188,   18,   95,
 /*  1260 */   156,  191,  191,  191,  198,  218,  198,   36,  188,  128,
 /*  1270 */   129,  130,  131,  132,  133,  156,  156,  140,  191,  218,
 /*  1280 */   163,  179,  179,    1,   15,   23,  115,  115,  240,  115,
 /*  1290 */   240,  115,  128,  129,  130,  131,  132,  133,   95,  110,

 /*  1300 */    22,   11,   23,   23,   23,   22,   22,  119,   23,  117,
 /*  1310 */   243,   25,   23,   25,  119,   22,   25,  119,   23,  246,
 /*  1320 */   118,  115,   23,  249,   47,   22,   22,   35,   23,   22,
 /*  1330 */    22,   22,   99,  106,   47,   19,   24,   20,  101,   39,
 /*  1340 */    25,   47,  137,  101,   22,   48,   48,    5,    1,  105,
 /*  1350 */    54,  126,   22,    1,  116,   17,  120,   20,  105,  116,
 /*  1360 */   126,   22,  127,   23,   15,   17,   60,  139,   22,    3,
 /*  1370 */   250,    4,   71,   71,
};
#define YY_SHIFT_USE_DFLT (-108)
#define YY_SHIFT_MAX 404
static const short yy_shift_ofst[] = {
 /*     0 */    23, 1038, 1040,  -19, 1040, 1164, 1164,  187,   78,  243,
 /*    10 */   119, 1164, 1164, 1164, 1164, 1164,  -48,  266,  347,  554,
 /*    20 */   148,   19,   19, -107,   50,  188,  257,  330,  403,  472,
 /*    30 */   541,  610,  679,  748,  817,  748,  748,  748,  748,  748,
 /*    40 */   748,  748,  748,  748,  748,  748,  748,  748,  748,  748,
 /*    50 */   748,  748,  748,  886,  955,  955, 1141, 1164, 1164, 1164,
 /*    60 */  1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164,
 /*    70 */  1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164,
 /*    80 */  1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164,
 /*    90 */  1164, 1164, 1164, 1164, 1164, 1164, 1164,  -64,  -64,   -1,
 /*   100 */    -1,   52,    6,  160,  400,  956,  554,  554,   25,  148,
 /*   110 */   -75, -108, -108, -108,   80,  124,  338,  338,  504,  540,
 /*   120 */   647,  574,  554,  574,  574,  554,  554,  554,  554,  554,
 /*   130 */   554,  554,  554,  554,  554,  554,  554,  554,  554,  554,
 /*   140 */   554,  554,  545,  662, -107, -107, -107, -108, -108, -108,
 /*   150 */   -21,  -21,  131,  212,  470,  418,  479,  484,  557,  544,
 /*   160 */   546,  482,  548,  552,  559,  645,  554,  554,  554,  554,
 /*   170 */   554,  761,  554,  554,  642,  554,  554,  759,  554,  554,
 /*   180 */   554,  554,  554,  463,  463,  463,  554,  554,  554,  419,
 /*   190 */   554,  554,  419,  554,  686,  597,  554,  554,  419,  554,
 /*   200 */   554,  554,  419,  554,  554,  554,  419,  419,  554,  554,
 /*   210 */   554,  554,  554,  766,  327,  201,  148,  730,  730,  788,
 /*   220 */   889,  889,  683,  889,  962,  889,  148,  889,  148,  115,
 /*   230 */    32,  683,  683,   32, 1131, 1131, 1131, 1131, 1144, 1144,
 /*   240 */  1139, -107, 1049, 1044, 1054, 1058, 1057, 1051, 1076, 1076,
 /*   250 */  1093, 1077, 1093, 1077, 1093, 1077, 1095, 1095, 1165, 1095,
 /*   260 */  1111, 1095, 1190, 1127, 1127, 1165, 1095, 1095, 1095, 1190,
 /*   270 */  1200, 1076, 1200, 1076, 1200, 1076, 1076, 1199, 1109, 1200,
 /*   280 */  1076, 1186, 1186, 1230, 1049, 1076, 1240, 1240, 1240, 1240,
 /*   290 */  1049, 1186, 1230, 1076, 1231, 1231, 1076, 1076, 1137, -108,
 /*   300 */  -108, -108, -108, -108,  466,  575,  617,  785,  755,  901,
 /*   310 */   957,  965,  271,  920,  963,  966,  970, 1045, 1052, 1059,
 /*   320 */  1060, 1075, 1034, 1081, 1041, 1282, 1269, 1262, 1171, 1172,
 /*   330 */  1174, 1176, 1203, 1189, 1278, 1279, 1280, 1283, 1290, 1284,
 /*   340 */  1281, 1286, 1285, 1289, 1288, 1188, 1291, 1195, 1288, 1192,
 /*   350 */  1293, 1198, 1202, 1206, 1295, 1299, 1292, 1277, 1303, 1287,
 /*   360 */  1304, 1305, 1307, 1308, 1294, 1309, 1233, 1227, 1316, 1317,
 /*   370 */  1312, 1237, 1300, 1296, 1297, 1315, 1298, 1205, 1242, 1322,
 /*   380 */  1342, 1347, 1244, 1301, 1302, 1225, 1330, 1238, 1352, 1338,
 /*   390 */  1236, 1337, 1243, 1253, 1234, 1339, 1235, 1340, 1348, 1306,
 /*   400 */  1349, 1228, 1346, 1366, 1367,
};
#define YY_REDUCE_USE_DFLT (-142)
#define YY_REDUCE_MAX 303
static const short yy_reduce_ofst[] = {
 /*     0 */  -141,  -49,  140,   77,  198,   67,   75,   -8,   66,  225,
 /*    10 */   165,  142,  209,  277,  279,  281,  130,  286,   81,  275,
 /*    20 */   196,  288,  293,  228,   83,   83,   83,   83,   83,   83,
 /*    30 */    83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 /*    40 */    83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 /*    50 */    83,   83,   83,   83,   83,   83,  349,  467,  493,  536,
 /*    60 */   555,  558,  561,  563,  565,  567,  605,  618,  622,  624,
 /*    70 */   626,  630,  633,  636,  674,  687,  691,  693,  695,  699,
 /*    80 */   704,  743,  756,  760,  762,  764,  768,  773,  775,  812,
 /*    90 */   825,  829,  831,  833,  837,  842,  844,   83,   83,   83,

 /*   100 */    83,  -17,   83,   83,  333,  361,   22,  566,   83, -124,
 /*   110 */    83,   83,   83,   83,  609,    1,  481,  517,  475,  475,
 /*   120 */   625,  220,  -45,  709,  774,  417,  729,  757,  758,  384,
 /*   130 */   231,  826,  214,  371,  512,  658,  863,  869,  881,  894,
 /*   140 */   637,  895,  301,  612,  752,  887,  888,   90,  650,  593,
 /*   150 */  -100,  -79,  -59,   -7,   38,   87,   38,   38,  101,  224,
 /*   160 */   270,  297,   38,  290,  355,  430,  398,  451,  631,  696,
 /*   170 */   702,  436,  355,  707,  469,  635,  771,  290,  790,  834,
 /*   180 */   847,  859,  915,  727,  890,  896,  921,  929,  939,   38,
 /*   190 */   942,  945,   38,  946,  864,  866,  958,  959,   38,  960,
 /*   200 */   961,  964,   38,  967,  968,  969,   38,   38,  973,  974,
 /*   210 */   975,  976,  977,  954,  917,  916,  950,  884,  897,  893,
 /*   220 */   952,  971,  925,  972,  953,  978,  979,  980,  984,  981,
 /*   230 */   938,  930,  931,  947,  994, 1001, 1003, 1006, 1008, 1011,
 /*   240 */  1007,  985,  982,  983,  987,  988,  986,  990, 1037, 1039,
 /*   250 */   991,  989,  992,  993,  995,  996, 1030, 1032, 1026, 1035,
 /*   260 */  1036, 1042, 1043,  997,  998, 1046, 1053, 1055, 1062, 1056,
 /*   270 */  1064, 1079, 1065, 1082, 1084, 1085, 1086, 1010, 1012, 1089,
 /*   280 */  1092, 1063, 1069, 1047, 1066, 1097, 1070, 1071, 1072, 1087,
 /*   290 */  1068, 1080, 1061, 1104, 1048, 1050, 1119, 1120, 1067, 1117,
 /*   300 */  1102, 1103, 1073, 1074,
};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */   615,  929,  848,  736,  929,  848,  929,  929,  875,  929,
 /*    10 */   904,  846,  929,  929,  929,  929,  820,  929,  875,  929,
 /*    20 */   652,  875,  875,  740,  771,  929,  929,  929,  929,  929,
 /*    30 */   929,  929,  929,  772,  929,  850,  845,  841,  843,  842,
 /*    40 */   849,  773,  762,  769,  776,  751,  888,  778,  779,  785,
 /*    50 */   786,  905,  903,  808,  807,  826,  929,  929,  929,  929,
 /*    60 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  929,
 /*    70 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  929,
 /*    80 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  929,
 /*    90 */   929,  929,  929,  929,  929,  929,  929,  810,  832,  809,
 /*   100 */   819,  645,  811,  812,  705,  640,  929,  929,  813,  929,
 /*   110 */   814,  827,  828,  829,  929,  929,  929,  929,  929,  929,
 /*   120 */   615,  736,  929,  736,  736,  929,  929,  929,  929,  929,
 /*   130 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  929,
 /*   140 */   929,  929,  929,  929,  929,  929,  929,  730,  740,  922,
 /*   150 */   929,  929,  696,  929,  929,  929,  929,  929,  929,  929,
 /*   160 */   929,  929,  929,  929,  929,  623,  621,  929,  929,  929,
 /*   170 */   929,  728,  929,  929,  654,  929,  929,  738,  929,  929,


 /*   180 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  642,
 /*   190 */   929,  929,  717,  929,  881,  929,  929,  929,  895,  929,
 /*   200 */   929,  929,  893,  929,  929,  929,  719,  781,  861,  929,
 /*   210 */   908,  910,  929,  929,  728,  737,  929,  929,  929,  844,
 /*   220 */   765,  765,  753,  765,  675,  765,  929,  765,  929,  678,
 /*   230 */   775,  753,  753,  775,  620,  620,  620,  620,  631,  631,
 /*   240 */   695,  929,  775,  766,  768,  758,  770,  929,  744,  744,
 /*   250 */   752,  757,  752,  757,  752,  757,  707,  707,  692,  707,
 /*   260 */   678,  707,  854,  858,  858,  692,  707,  707,  707,  854,
 /*   270 */   637,  744,  637,  744,  637,  744,  744,  885,  887,  637,
 /*   280 */   744,  709,  709,  787,  775,  744,  716,  716,  716,  716,
 /*   290 */   775,  709,  787,  744,  907,  907,  744,  744,  915,  662,
 /*   300 */   680,  680,  922,  927,  929,  929,  929,  929,  794,  929,
 /*   310 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  929,
 /*   320 */   929,  929,  868,  929,  929,  929,  629,  929,  799,  795,
 /*   330 */   929,  796,  929,  722,  929,  929,  929,  929,  929,  929,
 /*   340 */   929,  929,  929,  929,  847,  929,  759,  929,  767,  929,
 /*   350 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  929,
 /*   360 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  929,
 /*   370 */   929,  929,  929,  929,  883,  884,  929,  929,  929,  929,

 /*   380 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  929,
 /*   390 */   929,  929,  929,  929,  929,  929,  929,  929,  929,  914,
 /*   400 */   929,  929,  917,  616,  929,  611,  613,  614,  618,  619,
 /*   410 */   622,  649,  650,  651,  624,  625,  626,  627,  628,  630,
 /*   420 */   634,  632,  633,  635,  641,  643,  661,  663,  647,  665,
 /*   430 */   726,  727,  791,  720,  721,  725,  648,  802,  793,  797,
 /*   440 */   798,  800,  801,  815,  816,  818,  824,  831,  834,  817,
 /*   450 */   822,  823,  825,  830,  833,  723,  724,  837,  655,  656,
 /*   460 */   659,  660,  871,  873,  872,  874,  658,  657,  803,  806,
 /*   470 */   839,  840,  896,  897,  898,  899,  900,  835,  745,  838,
 /*   480 */   821,  760,  763,  764,  761,  729,  739,  747,  748,  749,
 /*   490 */   750,  734,  735,  741,  756,  789,  790,  754,  755,  742,
 /*   500 */   743,  731,  732,  733,  836,  792,  804,  805,  666,  667,
 /*   510 */   799,  668,  669,  670,  708,  711,  712,  713,  671,  690,
 /*   520 */   693,  694,  672,  679,  673,  674,  681,  682,  683,  686,
 /*   530 */   687,  688,  689,  684,  685,  855,  856,  859,  857,  676,
 /*   540 */   677,  691,  664,  653,  646,  697,  700,  701,  702,  703,
 /*   550 */   704,  706,  698,  699,  644,  636,  638,  746,  877,  886,
 /*   560 */   882,  878,  879,  880,  639,  851,  852,  710,  783,  784,
 /*   570 */   876,  889,  891,  788,  892,  894,  890,  919,  714,  715,
 /*   580 */   718,  860,  901,  774,  777,  780,  782,  862,  863,  864,
 /*   590 */   865,  866,  869,  870,  867,  902,  906,  909,  911,  912,
 /*   600 */   913,  916,  918,  923,  924,  925,  928,  926,  617,  612,
};
#define YY_SZ_ACTTAB (int)(sizeof(yy_action)/sizeof(yy_action[0]))

/* The next table maps tokens into fallback tokens.  If a construct
** like the following:
** 
**      %fallback ID X Y Z.

    'D','R','O','P','F','A','I','L','F','R','O','M','F','U','L','L','G','L',
    'O','B','Y','I','F','I','S','N','U','L','L','O','R','D','E','R','E','S',
    'T','R','I','C','T','O','U','T','E','R','I','G','H','T','R','O','L','L',
    'B','A','C','K','R','O','W','U','N','I','O','N','U','S','I','N','G','V',
    'A','C','U','U','M','V','I','E','W','I','N','I','T','I','A','L','L','Y',
  };
  static const unsigned char aHash[127] = {
      70,  99, 112,  68,   0,  43,   0,   0,  76,   0,  71,   0,   0,
      41,  12,  72,  15,   0, 111,  79,  49, 106,   0,  19,   0,   0,
     116,   0, 114, 109,   0,  22,  87,   0,   9,   0,   0,  64,  65,
       0,  63,   6,   0,  47,  84,  96,   0, 113,  95,   0,   0,  44,
       0,  97,  24,   0,  17,   0, 117,  48,  23,   0,   5, 104,  25,
      90,   0,   0, 119, 100,  55, 118,  52,   7,  50,   0,  85,   0,
      94,  26,   0,  93,   0,   0,   0,  89,  86,  91,  82, 103,  14,
      38, 102,   0,  75,   0,  18,  83, 105,  31,   0, 115,  74, 107,
      57,  45,  78,   0,   0,  88,  39,   0, 110,   0,  35,   0,   0,
      28,   0,  80,  53,  58,   0,  20,  56,   0,  51,
  };
  static const unsigned char aNext[119] = {
       0,   0,   0,   0,   4,   0,   0,   0,   0,   0,   0,   0,   0,
       0,   2,   0,   0,   0,   0,   0,   0,  13,   0,   0,   0,   0,
       0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
       0,   0,   0,   0,  32,  21,   0,   0,   0,  42,   3,  46,   0,
       0,   0,   0,  29,   0,   0,  37,   0,   0,   0,   1,  60,   0,
       0,  61,   0,  40,   0,   0,   0,   0,   0,   0,   0,  59,   0,
       0,   0,   0,  30,  54,  16,  33,  10,   0,   0,   0,   0,   0,
       0,   0,  11,  66,  73,   0,   8,   0,  98,  92,   0, 101,   0,
      81,   0,  69,   0,   0, 108,  27,  36,  67,  77,   0,  34,  62,
       0,   0,
  };
  static const unsigned char aLen[119] = {
       7,   7,   5,   4,   6,   4,   5,   3,   6,   7,   3,   6,   6,
       7,   7,   3,   8,   2,   6,   5,   4,   4,   3,  10,   4,   6,
      11,   2,   7,   5,   5,   9,   6,   9,   9,   7,  10,  10,   4,
       6,   2,   3,   4,   9,   2,   6,   5,   6,   6,   5,   6,   5,
       5,   7,   7,   7,   3,   4,   4,   7,   3,   6,   4,   7,   6,
      12,   6,   9,   4,   6,   5,   4,   7,   6,   5,   6,   7,   5,
       4,   5,   6,   5,   7,   3,   7,  13,   2,   2,   4,   6,   6,
       8,   5,  17,  12,   7,   8,   8,   2,   4,   4,   4,   4,   4,
       2,   2,   6,   5,   8,   5,   5,   8,   3,   5,   5,   6,   4,
       9,   3,
  };
  static const unsigned short int aOffset[119] = {
       0,   2,   2,   8,   9,  14,  16,  20,  23,  25,  25,  29,  33,
      36,  41,  46,  48,  53,  54,  59,  62,  65,  67,  69,  78,  81,
      86,  95,  96, 101, 105, 109, 117, 122, 128, 136, 142, 152, 159,
     162, 162, 165, 167, 167, 171, 176, 179, 184, 189, 194, 197, 203,
     206, 210, 217, 223, 223, 226, 229, 233, 234, 238, 244, 248, 255,
     261, 273, 279, 288, 290, 296, 301, 303, 310, 315, 320, 326, 332,
     337, 341, 344, 350, 354, 361, 363, 370, 372, 374, 383, 387, 393,
     399, 407, 412, 412, 428, 435, 442, 443, 450, 454, 458, 462, 466,
     469, 471, 473, 479, 483, 491, 495, 500, 508, 511, 516, 521, 527,
     531, 536,
  };
  static const unsigned char aCode[119] = {
    TK_REINDEX,    TK_INDEXED,    TK_INDEX,      TK_DESC,       TK_ESCAPE,     
    TK_EACH,       TK_CHECK,      TK_KEY,        TK_BEFORE,     TK_FOREIGN,    
    TK_FOR,        TK_IGNORE,     TK_LIKE_KW,    TK_EXPLAIN,    TK_INSTEAD,    
    TK_ADD,        TK_DATABASE,   TK_AS,         TK_SELECT,     TK_TABLE,      
    TK_JOIN_KW,    TK_THEN,       TK_END,        TK_DEFERRABLE, TK_ELSE,       
    TK_EXCEPT,     TK_TRANSACTION,TK_ON,         TK_JOIN_KW,    TK_ALTER,      
    TK_RAISE,      TK_EXCLUSIVE,  TK_EXISTS,     TK_SAVEPOINT,  TK_INTERSECT,  
    TK_TRIGGER,    TK_REFERENCES, TK_CONSTRAINT, TK_INTO,       TK_OFFSET,     
    TK_OF,         TK_SET,        TK_TEMP,       TK_TEMP,       TK_OR,         
    TK_UNIQUE,     TK_QUERY,      TK_ATTACH,     TK_HAVING,     TK_GROUP,      
    TK_UPDATE,     TK_BEGIN,      TK_JOIN_KW,    TK_RELEASE,    TK_BETWEEN,    
    TK_NOTNULL,    TK_NOT,        TK_NULL,       TK_LIKE_KW,    TK_CASCADE,    
    TK_ASC,        TK_DELETE,     TK_CASE,       TK_COLLATE,    TK_CREATE,     
    TK_CTIME_KW,   TK_DETACH,     TK_IMMEDIATE,  TK_JOIN,       TK_INSERT,     
    TK_MATCH,      TK_PLAN,       TK_ANALYZE,    TK_PRAGMA,     TK_ABORT,      
    TK_VALUES,     TK_VIRTUAL,    TK_LIMIT,      TK_WHEN,       TK_WHERE,      
    TK_RENAME,     TK_AFTER,      TK_REPLACE,    TK_AND,        TK_DEFAULT,    
    TK_AUTOINCR,   TK_TO,         TK_IN,         TK_CAST,       TK_COLUMNKW,   
    TK_COMMIT,     TK_CONFLICT,   TK_JOIN_KW,    TK_CTIME_KW,   TK_CTIME_KW,   

      testcase( i==2 ); /* TK_INDEX */
      testcase( i==3 ); /* TK_DESC */
      testcase( i==4 ); /* TK_ESCAPE */
      testcase( i==5 ); /* TK_EACH */
      testcase( i==6 ); /* TK_CHECK */
      testcase( i==7 ); /* TK_KEY */
      testcase( i==8 ); /* TK_BEFORE */
      testcase( i==9 ); /* TK_FOREIGN */
      testcase( i==10 ); /* TK_FOR */
      testcase( i==11 ); /* TK_IGNORE */
      testcase( i==12 ); /* TK_LIKE_KW */
      testcase( i==13 ); /* TK_EXPLAIN */
      testcase( i==14 ); /* TK_INSTEAD */
      testcase( i==15 ); /* TK_ADD */
      testcase( i==16 ); /* TK_DATABASE */
      testcase( i==17 ); /* TK_AS */

      testcase( i==48 ); /* TK_HAVING */
      testcase( i==49 ); /* TK_GROUP */
      testcase( i==50 ); /* TK_UPDATE */
      testcase( i==51 ); /* TK_BEGIN */
      testcase( i==52 ); /* TK_JOIN_KW */
      testcase( i==53 ); /* TK_RELEASE */
      testcase( i==54 ); /* TK_BETWEEN */
      testcase( i==55 ); /* TK_NOTNULL */
      testcase( i==56 ); /* TK_NOT */
      testcase( i==57 ); /* TK_NULL */
      testcase( i==58 ); /* TK_LIKE_KW */
      testcase( i==59 ); /* TK_CASCADE */
      testcase( i==60 ); /* TK_ASC */
      testcase( i==61 ); /* TK_DELETE */
      testcase( i==62 ); /* TK_CASE */
      testcase( i==63 ); /* TK_COLLATE */

**   root                - contents of root node
**
** If the root node is a leaf node, then start_block,
** leaves_end_block, and end_block are all 0.
**
**
**** Segment merging ****
** To amortize update costs, segments are grouped into levels and
** merged in batches.  Each increase in level represents exponentially
** more documents.
**
** New documents (actually, document updates) are tokenized and
** written individually (using LeafWriter) to a level 0 segment, with
** incrementing idx.  When idx reaches MERGE_COUNT (default 16), all
** level 0 segments are merged into a single level 1 segment.  Level 1
** is populated like level 0, and eventually MERGE_COUNT level 1

    rc = sqlite3_create_module_v2(db, "rtree_i32", &rtreeModule, c, 0);
  }

  return rc;
}

#if !SQLITE_CORE
SQLITE_API int sqlite3_extension_init(
  sqlite3 *db,
  char **pzErrMsg,
  const sqlite3_api_routines *pApi
){
  SQLITE_EXTENSION_INIT2(pApi)
  return sqlite3RtreeInit(db);
}

** on how SQLite interfaces are suppose to operate.
**
** The name of this file under configuration management is "sqlite.h.in".
** The makefile makes some minor changes to this file (such as inserting
** the version number) and changes its name to "sqlite3.h" as
** part of the build process.
**
** @(#) $Id: sqlite.h.in,v 1.421 2008/12/30 06:24:58 danielk1977 Exp $
*/
#ifndef _SQLITE3_H_
#define _SQLITE3_H_
#include <stdarg.h>     /* Needed for the definition of va_list */

/*
** Make sure we can call this stuff from C++.

**          evaluate to a string literal that is the SQLite version
**          with which the header file is associated.
**
** {H10014} The SQLITE_VERSION_NUMBER #define shall resolve to an integer
**          with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z
**          are the major version, minor version, and release number.
*/
#define SQLITE_VERSION         "3.6.10"
#define SQLITE_VERSION_NUMBER  3006010

/*
** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100>
** KEYWORDS: sqlite3_version
**
** These features provide the same information as the [SQLITE_VERSION]
** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated

#define SQLITE_DROP_TEMP_VIEW       15   /* View Name       NULL            */
#define SQLITE_DROP_TRIGGER         16   /* Trigger Name    Table Name      */
#define SQLITE_DROP_VIEW            17   /* View Name       NULL            */
#define SQLITE_INSERT               18   /* Table Name      NULL            */
#define SQLITE_PRAGMA               19   /* Pragma Name     1st arg or NULL */
#define SQLITE_READ                 20   /* Table Name      Column Name     */
#define SQLITE_SELECT               21   /* NULL            NULL            */
#define SQLITE_TRANSACTION          22   /* Operation       NULL            */
#define SQLITE_UPDATE               23   /* Table Name      Column Name     */
#define SQLITE_ATTACH               24   /* Filename        NULL            */
#define SQLITE_DETACH               25   /* Database Name   NULL            */
#define SQLITE_ALTER_TABLE          26   /* Database Name   Table Name      */
#define SQLITE_REINDEX              27   /* Index Name      NULL            */
#define SQLITE_ANALYZE              28   /* Table Name      NULL            */
#define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */
#define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */
#define SQLITE_FUNCTION             31   /* NULL            Function Name   */
#define SQLITE_SAVEPOINT            32   /* Operation       Savepoint Name  */
#define SQLITE_COPY                  0   /* No longer used */

/*
** CAPI3REF: Tracing And Profiling Functions {H12280} <S60400>
** EXPERIMENTAL
**
** These routines register callback functions that can be used for