System.Data.SQLite

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains C code routines that used to generate VDBE code
** that implements the ALTER TABLE command.
**
** $Id: alter.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>

/*
** The code in this file only exists if we are not omitting the
** ALTER TABLE logic from the build.

/*
** 2005 July 8
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains code associated with the ANALYZE command.
**
** @(#) $Id: analyze.c,v 1.2 2005/09/01 06:07:55 rmsimpson Exp $
*/
#ifndef SQLITE_OMIT_ANALYZE
#include "sqliteInt.h"

/*
** This routine generates code that opens the sqlite_stat1 table on cursor
** iStatCur.

  Vdbe *v;         /* The virtual machine being built up */
  int i;           /* Loop counter */
  int topOfLoop;   /* The top of the loop */
  int endOfLoop;   /* The end of the loop */
  int addr;        /* The address of an instruction */

  v = sqlite3GetVdbe(pParse);
  if( pTab==0 || pTab->pIndex==0 || pTab->pIndex->pNext==0 ){
    /* Do no analysis for tables with fewer than 2 indices */
    return;
  }

#ifndef SQLITE_OMIT_AUTHORIZATION
  if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
      pParse->db->aDb[pTab->iDb].zName ) ){
    return;

    **    mem[iMem+nCol+1]       Last observed value of column 1
    **    ...
    **    mem[iMem+nCol+nCol]:   Last observed value of column N
    **
    ** Cells iMem through iMem+nCol are initialized to 0.  The others
    ** are initialized to NULL.
    */
    sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
    for(i=0; i<=nCol; i++){
      sqlite3VdbeAddOp(v, OP_MemStore, iMem+i, i==nCol);
    }
    sqlite3VdbeAddOp(v, OP_Null, 0, 0);
    for(i=0; i<nCol; i++){
      sqlite3VdbeAddOp(v, OP_MemStore, iMem+nCol+i+1, i==nCol-1);
    }

    /* Do the analysis.
    */
    endOfLoop = sqlite3VdbeMakeLabel(v);
    sqlite3VdbeAddOp(v, OP_Rewind, iIdxCur, endOfLoop);
    topOfLoop = sqlite3VdbeCurrentAddr(v);

        sqlite3VdbeAddOp(v, OP_Concat, nCol*2-1, 0);
      }else{
        sqlite3VdbeAddOp(v, OP_Dup, 1, 0);
      }
    }
    sqlite3VdbeOp3(v, OP_MakeRecord, 3, 0, "ttt", 0);
    sqlite3VdbeAddOp(v, OP_Insert, iStatCur, 0);
    sqlite3VdbeChangeP2(v, addr, sqlite3VdbeCurrentAddr(v));
  }
}

/*
** Generate code that will cause the most recent index analysis to
** be laoded into internal hash tables where is can be used.
*/

  analysisInfo *pInfo = (analysisInfo*)pData;
  Index *pIndex;
  int i, c;
  unsigned int v;
  const char *z;

  assert( argc==2 );
  if( argv[0]==0 || argv[1]==0 ){
    return 0;
  }
  pIndex = sqlite3FindIndex(pInfo->db, argv[0], pInfo->zDatabase);
  if( pIndex==0 ){
    return 0;
  }
  z = argv[1];

/*
** 2003 April 6
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains code used to implement the ATTACH and DETACH commands.
**
** $Id: attach.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"

/*
** This routine is called by the parser to process an ATTACH statement:
**
**     ATTACH DATABASE filename AS dbname

**
*************************************************************************
** This file contains code used to implement the sqlite3_set_authorizer()
** API.  This facility is an optional feature of the library.  Embedded
** systems that do not need this facility may omit it by recompiling
** the library with -DSQLITE_OMIT_AUTHORIZATION=1
**
** $Id: auth.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"

/*
** All of the code in this file may be omitted by defining a single
** macro.
*/

/*
** 2004 April 6
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** $Id: btree.c,v 1.10 2005/09/01 06:07:55 rmsimpson Exp $
**
** This file implements a external (disk-based) database using BTrees.
** For a detailed discussion of BTrees, refer to
**
**     Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3:
**     "Sorting And Searching", pages 473-480. Addison-Wesley
**     Publishing Company, Reading, Massachusetts.

  u8 *pPtrmap;    /* The pointer map page */
  Pgno iPtrmap;   /* The pointer map page number */
  int offset;     /* Offset in pointer map page */
  int rc;

  assert( pBt->autoVacuum );
  if( key==0 ){
    return SQLITE_CORRUPT;
  }
  iPtrmap = PTRMAP_PAGENO(pBt->usableSize, key);
  rc = sqlite3pager_get(pBt->pPager, iPtrmap, (void **)&pPtrmap);
  if( rc!=SQLITE_OK ){
    return rc;
  }
  offset = PTRMAP_PTROFFSET(pBt->usableSize, key);

  }

  offset = PTRMAP_PTROFFSET(pBt->usableSize, key);
  if( pEType ) *pEType = pPtrmap[offset];
  if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]);

  sqlite3pager_unref(pPtrmap);
  if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT;
  return SQLITE_OK;
}

#endif /* SQLITE_OMIT_AUTOVACUUM */

/*
** Given a btree page and a cell index (0 means the first cell on

  pBt = pPage->pBt;
  assert( pBt!=0 );
  assert( pParent==0 || pParent->pBt==pBt );
  assert( pPage->pgno==sqlite3pager_pagenumber(pPage->aData) );
  assert( pPage->aData == &((unsigned char*)pPage)[-pBt->pageSize] );
  if( pPage->pParent!=pParent && (pPage->pParent!=0 || pPage->isInit) ){
    /* The parent page should never change unless the file is corrupt */
    return SQLITE_CORRUPT; /* bkpt-CORRUPT */
  }
  if( pPage->isInit ) return SQLITE_OK;
  if( pPage->pParent==0 && pParent!=0 ){
    pPage->pParent = pParent;
    sqlite3pager_ref(pParent->aData);
  }
  hdr = pPage->hdrOffset;
  data = pPage->aData;
  decodeFlags(pPage, data[hdr]);
  pPage->nOverflow = 0;
  pPage->idxShift = 0;
  usableSize = pBt->usableSize;
  pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
  top = get2byte(&data[hdr+5]);
  pPage->nCell = get2byte(&data[hdr+3]);
  if( pPage->nCell>MX_CELL(pBt) ){
    /* To many cells for a single page.  The page must be corrupt */
    return SQLITE_CORRUPT; /* bkpt-CORRUPT */
  }
  if( pPage->nCell==0 && pParent!=0 && pParent->pgno!=1 ){
    /* All pages must have at least one cell, except for root pages */
    return SQLITE_CORRUPT; /* bkpt-CORRUPT */
  }

  /* Compute the total free space on the page */
  pc = get2byte(&data[hdr+1]);
  nFree = data[hdr+7] + top - (cellOffset + 2*pPage->nCell);
  while( pc>0 ){
    int next, size;
    if( pc>usableSize-4 ){
      /* Free block is off the page */
      return SQLITE_CORRUPT;  /* bkpt-CORRUPT */
    }
    next = get2byte(&data[pc]);
    size = get2byte(&data[pc+2]);
    if( next>0 && next<=pc+size+3 ){
      /* Free blocks must be in accending order */
      return SQLITE_CORRUPT;  /* bkpt-CORRUPT */
    }
    nFree += size;
    pc = next;
  }
  pPage->nFree = nFree;
  if( nFree>=usableSize ){
    /* Free space cannot exceed total page size */
    return SQLITE_CORRUPT;  /* bkpt-CORRUPT */
  }

  pPage->isInit = 1;
  pageIntegrity(pPage);
  return SQLITE_OK;
}

  Btree *pBt,          /* The database file */
  Pgno pgno,           /* Number of the page to get */
  MemPage **ppPage,    /* Write the page pointer here */
  MemPage *pParent     /* Parent of the page */
){
  int rc;
  if( pgno==0 ){
    return SQLITE_CORRUPT;  /* bkpt-CORRUPT */
  }
  rc = getPage(pBt, pgno, ppPage);
  if( rc==SQLITE_OK && (*ppPage)->isInit==0 ){
    rc = initPage(*ppPage, pParent);
  }
  return rc;
}

** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
**                   overflow page in the list.
*/
static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
  if( eType==PTRMAP_OVERFLOW2 ){
    /* The pointer is always the first 4 bytes of the page in this case.  */
    if( get4byte(pPage->aData)!=iFrom ){
      return SQLITE_CORRUPT;
    }
    put4byte(pPage->aData, iTo);
  }else{
    int isInitOrig = pPage->isInit;
    int i;
    int nCell;

        }
      }
    }
  
    if( i==nCell ){
      if( eType!=PTRMAP_BTREE || 
          get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
        return SQLITE_CORRUPT;
      }
      put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
    }

    pPage->isInit = isInitOrig;
  }
  return SQLITE_OK;

#ifndef NDEBUG
  int nRef = *sqlite3pager_stats(pPager);
#endif

  assert( pBt->autoVacuum );
  if( PTRMAP_ISPAGE(pgsz, sqlite3pager_pagecount(pPager)) ){
    return SQLITE_CORRUPT;
  }

  /* Figure out how many free-pages are in the database. If there are no
  ** free pages, then auto-vacuum is a no-op.
  */
  nFreeList = get4byte(&pBt->pPage1->aData[36]);
  if( nFreeList==0 ){
    *nTrunc = 0;
    return SQLITE_OK;
  }

  origSize = sqlite3pager_pagecount(pPager);
  nPtrMap = (nFreeList-origSize+PTRMAP_PAGENO(pgsz, origSize)+pgsz/5)/(pgsz/5);
  finSize = origSize - nFreeList - nPtrMap;
  if( origSize>PENDING_BYTE_PAGE(pBt) && finSize<=PENDING_BYTE_PAGE(pBt) ){
    finSize--;
    if( PTRMAP_ISPAGE(pBt->usableSize, finSize) ){
      finSize--;
    }
  }
  TRACE(("AUTOVACUUM: Begin (db size %d->%d)\n", origSize, finSize));

    if( PTRMAP_ISPAGE(pgsz, iDbPage) || iDbPage==PENDING_BYTE_PAGE(pBt) ){
      continue;
    }

    rc = ptrmapGet(pBt, iDbPage, &eType, &iPtrPage);
    if( rc!=SQLITE_OK ) goto autovacuum_out;
    if( eType==PTRMAP_ROOTPAGE ){
      rc = SQLITE_CORRUPT;
      goto autovacuum_out;
    }

    /* If iDbPage is free, do not swap it.  */
    if( eType==PTRMAP_FREEPAGE ){
      continue;
    }

        offset -= ovflSize;
      }
      sqlite3pager_unref(aPayload);
    }
  }

  if( amt>0 ){
    return SQLITE_CORRUPT; /* bkpt-CORRUPT */
  }
  return SQLITE_OK;
}

/*
** Read part of the key associated with cursor pCur.  Exactly
** "amt" bytes will be transfered into pBuf[].  The transfer
** begins at "offset".
**
** Return SQLITE_OK on success or an error code if anything goes
** wrong.  An error is returned if "offset+amt" is larger than
** the available payload.
*/
int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
  assert( pCur->isValid );
  assert( pCur->pPage!=0 );
  if( pCur->pPage->intKey ){
    return SQLITE_CORRUPT;
  }
  assert( pCur->pPage->intKey==0 );
  assert( pCur->idx>=0 && pCur->idx<pCur->pPage->nCell );
  return getPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
}

/*

static const unsigned char *fetchPayload(
  BtCursor *pCur,      /* Cursor pointing to entry to read from */
  int *pAmt,           /* Write the number of available bytes here */
  int skipKey          /* read beginning at data if this is true */
){
  unsigned char *aPayload;
  MemPage *pPage;
  Btree *pBt;
  u32 nKey;
  int nLocal;

  assert( pCur!=0 && pCur->pPage!=0 );
  assert( pCur->isValid );
  pBt = pCur->pBt;
  pPage = pCur->pPage;
  pageIntegrity(pPage);
  assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
  getCellInfo(pCur);
  aPayload = pCur->info.pCell;
  aPayload += pCur->info.nHeader;
  if( pPage->intKey ){

  pOldPage = pCur->pPage;
  pOldPage->idxShift = 0;
  releasePage(pOldPage);
  pCur->pPage = pNewPage;
  pCur->idx = 0;
  pCur->info.nSize = 0;
  if( pNewPage->nCell<1 ){
    return SQLITE_CORRUPT; /* bkpt-CORRUPT */
  }
  return SQLITE_OK;
}

/*
** Return true if the page is the virtual root of its table.
**

**
** pCur->idx is set to the cell index that contains the pointer
** to the page we are coming from.  If we are coming from the
** right-most child page then pCur->idx is set to one more than
** the largest cell index.
*/
static void moveToParent(BtCursor *pCur){
  Pgno oldPgno;
  MemPage *pParent;
  MemPage *pPage;
  int idxParent;

  assert( pCur->isValid );
  pPage = pCur->pPage;
  assert( pPage!=0 );
  assert( !isRootPage(pPage) );
  pageIntegrity(pPage);
  pParent = pPage->pParent;
  assert( pParent!=0 );
  pageIntegrity(pParent);
  idxParent = pPage->idxParent;
  sqlite3pager_ref(pParent->aData);
  oldPgno = pPage->pgno;
  releasePage(pPage);
  pCur->pPage = pParent;
  pCur->info.nSize = 0;
  assert( pParent->idxShift==0 );
  pCur->idx = idxParent;
}

    int lwr, upr;
    Pgno chldPg;
    MemPage *pPage = pCur->pPage;
    int c = -1;  /* pRes return if table is empty must be -1 */
    lwr = 0;
    upr = pPage->nCell-1;
    if( !pPage->intKey && pKey==0 ){
      return SQLITE_CORRUPT;
    }
    pageIntegrity(pPage);
    while( lwr<=upr ){
      void *pCellKey;
      i64 nCellKey;
      pCur->idx = (lwr+upr)/2;
      pCur->info.nSize = 0;

        *pPgno = iTrunk;
        memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
        *ppPage = pTrunk;
        pTrunk = 0;
        TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
      }else if( k>pBt->usableSize/4 - 8 ){
        /* Value of k is out of range.  Database corruption */
        return SQLITE_CORRUPT; /* bkpt-CORRUPT */
#ifndef SQLITE_OMIT_AUTOVACUUM
      }else if( searchList && nearby==iTrunk ){
        /* The list is being searched and this trunk page is the page
        ** to allocate, regardless of whether it has leaves.
        */
        assert( *pPgno==iTrunk );
        *ppPage = pTrunk;

        }

        iPage = get4byte(&aData[8+closest*4]);
        if( !searchList || iPage==nearby ){
          *pPgno = iPage;
          if( *pPgno>sqlite3pager_pagecount(pBt->pPager) ){
            /* Free page off the end of the file */
            return SQLITE_CORRUPT; /* bkpt-CORRUPT */
          }
          TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
                 ": %d more free pages\n",
                 *pPgno, closest+1, k, pTrunk->pgno, n-1));
          if( closest<k-1 ){
            memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
          }

  if( info.iOverflow==0 ){
    return SQLITE_OK;  /* No overflow pages. Return without doing anything */
  }
  ovflPgno = get4byte(&pCell[info.iOverflow]);
  while( ovflPgno!=0 ){
    MemPage *pOvfl;
    if( ovflPgno>sqlite3pager_pagecount(pBt->pPager) ){
      return SQLITE_CORRUPT;
    }
    rc = getPage(pBt, ovflPgno, &pOvfl);
    if( rc ) return rc;
    ovflPgno = get4byte(pOvfl->aData);
    rc = freePage(pOvfl);
    sqlite3pager_unref(pOvfl->aData);
    if( rc ) return rc;

    int notUsed;
    unsigned char *tempCell = 0;
    assert( !pPage->leafData );
    getTempCursor(pCur, &leafCur);
    rc = sqlite3BtreeNext(&leafCur, &notUsed);
    if( rc!=SQLITE_OK ){
      if( rc!=SQLITE_NOMEM ){
        rc = SQLITE_CORRUPT;  /* bkpt-CORRUPT */
      }
    }
    if( rc==SQLITE_OK ){
      rc = sqlite3pager_write(leafCur.pPage->aData);
    }
    if( rc==SQLITE_OK ){
      TRACE(("DELETE: table=%d delete internal from %d replace from leaf %d\n",

){
  MemPage *pPage = 0;
  int rc;
  unsigned char *pCell;
  int i;

  if( pgno>sqlite3pager_pagecount(pBt->pPager) ){
    return SQLITE_CORRUPT;
  }

  rc = getAndInitPage(pBt, pgno, &pPage, pParent);
  if( rc ) goto cleardatabasepage_out;
  rc = sqlite3pager_write(pPage->aData);
  if( rc ) goto cleardatabasepage_out;
  for(i=0; i<pPage->nCell; i++){

  MemPage *pPage;
  int i, rc, depth, d2, pgno, cnt;
  int hdr, cellStart;
  int nCell;
  u8 *data;
  BtCursor cur;
  Btree *pBt;
  int maxLocal, usableSize;
  char zContext[100];
  char *hit;

  sprintf(zContext, "Page %d: ", iPage);

  /* Check that the page exists
  */
  cur.pBt = pBt = pCheck->pBt;
  usableSize = pBt->usableSize;
  if( iPage==0 ) return 0;
  if( checkRef(pCheck, iPage, zParentContext) ) return 0;
  if( (rc = getPage(pBt, (Pgno)iPage, &pPage))!=0 ){
    checkAppendMsg(pCheck, zContext,
       "unable to get the page. error code=%d", rc);
    return 0;
  }
  maxLocal = pPage->leafData ? pBt->maxLeaf : pBt->maxLocal;
  if( (rc = initPage(pPage, pParent))!=0 ){
    checkAppendMsg(pCheck, zContext, "initPage() returns error code %d", rc);
    releasePage(pPage);
    return 0;
  }

  /* Check out all the cells.

** must be active for both files.
**
** The size of file pBtFrom may be reduced by this operation.
** If anything goes wrong, the transaction on pBtFrom is rolled back.
*/
int sqlite3BtreeCopyFile(Btree *pBtTo, Btree *pBtFrom){
  int rc = SQLITE_OK;
  Pgno i, nPage, nToPage;

  if( pBtTo->inTrans!=TRANS_WRITE || pBtFrom->inTrans!=TRANS_WRITE ){
    return SQLITE_ERROR;
  }
  if( pBtTo->pCursor ) return SQLITE_BUSY;
  nToPage = sqlite3pager_pagecount(pBtTo->pPager);
  nPage = sqlite3pager_pagecount(pBtFrom->pPager);

  for(i=1; rc==SQLITE_OK && i<=nPage; i++){
    void *pPage;

    rc = sqlite3pager_get(pBtFrom->pPager, i, &pPage);
    if( rc ) break;
    rc = sqlite3pager_overwrite(pBtTo->pPager, i, pPage);
    if( rc ) break;
    sqlite3pager_unref(pPage);
  }
  for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){
    void *pPage;

    rc = sqlite3pager_get(pBtTo->pPager, i, &pPage);
    if( rc ) break;
    rc = sqlite3pager_write(pPage);
    sqlite3pager_unref(pPage);
    sqlite3pager_dont_write(pBtTo->pPager, i);
  }
  if( !rc && nPage<nToPage ){

**    May you share freely, never taking more than you give.
**
*************************************************************************
** This header file defines the interface that the sqlite B-Tree file
** subsystem.  See comments in the source code for a detailed description
** of what each interface routine does.
**
** @(#) $Id: btree.h,v 1.9 2005/09/01 06:07:55 rmsimpson Exp $
*/
#ifndef _BTREE_H_
#define _BTREE_H_

/* TODO: This definition is just included so other modules compile. It
** needs to be revisited.
*/

**     CREATE INDEX
**     DROP INDEX
**     creating ID lists
**     BEGIN TRANSACTION
**     COMMIT
**     ROLLBACK
**
** $Id: build.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>

/*
** This routine is called when a new SQL statement is beginning to
** be parsed.  Initialize the pParse structure as needed.

    ** set for each database that is used.  Generate code to start a
    ** transaction on each used database and to verify the schema cookie
    ** on each used database.
    */
    if( pParse->cookieGoto>0 ){
      u32 mask;
      int iDb;
      sqlite3VdbeChangeP2(v, pParse->cookieGoto-1, sqlite3VdbeCurrentAddr(v));
      for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){
        if( (mask & pParse->cookieMask)==0 ) continue;
        sqlite3VdbeAddOp(v, OP_Transaction, iDb, (mask & pParse->writeMask)!=0);
        sqlite3VdbeAddOp(v, OP_VerifyCookie, iDb, pParse->cookieValue[iDb]);
      }
      sqlite3VdbeAddOp(v, OP_Goto, 0, pParse->cookieGoto);
    }


    /* Add a No-op that contains the complete text of the compiled SQL
    ** statement as its P3 argument.  This does not change the functionality
    ** of the program. 
    **
    ** This is used to implement sqlite3_trace().
    */
    sqlite3VdbeOp3(v, OP_Noop, 0, 0, pParse->zSql, pParse->zTail-pParse->zSql);

  }


  /* Get the VDBE program ready for execution
  */
  if( v && pParse->nErr==0 ){
    FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;
    sqlite3VdbeTrace(v, trace);
    sqlite3VdbeMakeReady(v, pParse->nVar, pParse->nMem+3,
                         pParse->nTab+3, pParse->nMaxDepth+1, pParse->explain);
    pParse->rc = SQLITE_DONE;
    pParse->colNamesSet = 0;
  }else if( pParse->rc==SQLITE_OK ){
    pParse->rc = SQLITE_ERROR;
  }
  pParse->nTab = 0;
  pParse->nMem = 0;

** Not everything is nestable.  This facility is designed to permit
** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER.  Use
** care if you decide to try to use this routine for some other purposes.
*/
void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
  va_list ap;
  char *zSql;
  int rc;
# define SAVE_SZ  (sizeof(Parse) - offsetof(Parse,nVar))
  char saveBuf[SAVE_SZ];

  if( pParse->nErr ) return;
  assert( pParse->nested<10 );  /* Nesting should only be of limited depth */
  va_start(ap, zFormat);
  zSql = sqlite3VMPrintf(zFormat, ap);
  va_end(ap);
  if( zSql==0 ){
    return;   /* A malloc must have failed */
  }
  pParse->nested++;
  memcpy(saveBuf, &pParse->nVar, SAVE_SZ);
  memset(&pParse->nVar, 0, SAVE_SZ);
  rc = sqlite3RunParser(pParse, zSql, 0);
  sqliteFree(zSql);
  memcpy(&pParse->nVar, saveBuf, SAVE_SZ);
  pParse->nested--;
}

/*
** Locate the in-memory structure that describes a particular database

  Token *pStart,   /* The "CREATE" token */
  Token *pName1,   /* First part of the name of the table or view */
  Token *pName2,   /* Second part of the name of the table or view */
  int isTemp,      /* True if this is a TEMP table */
  int isView       /* True if this is a VIEW */
){
  Table *pTable;
  Index *pIdx;
  char *zName = 0; /* The name of the new table */
  sqlite3 *db = pParse->db;
  Vdbe *v;
  int iDb;         /* Database number to create the table in */
  Token *pName;    /* Unqualified name of the table to create */

  /* The table or view name to create is passed to this routine via tokens

    goto begin_table_error;
  }
  pTable = sqlite3FindTable(db, zName, db->aDb[iDb].zName);
  if( pTable ){
    sqlite3ErrorMsg(pParse, "table %T already exists", pName);
    goto begin_table_error;
  }
  if( (pIdx = sqlite3FindIndex(db, zName, 0))!=0 && 
      ( iDb==0 || !db->init.busy) ){
    sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
    goto begin_table_error;
  }
  pTable = sqliteMalloc( sizeof(Table) );
  if( pTable==0 ){
    pParse->rc = SQLITE_NOMEM;
    pParse->nErr++;

  int i;
  Column *pCol;

  if( (p = pParse->pNewTable)==0 ) return;
  i = p->nCol-1;
  if( i<0 ) return;
  pCol = &p->aCol[i];
  assert( pCol->zType==0 );
  pCol->zType = sqlite3NameFromToken(pType);
  pCol->affinity = sqlite3AffinityType(pType);
}

/*
** The expression is the default value for the most recently added column
** of the table currently under construction.

  }else{
    for(i=0; i<pList->nExpr; i++){
      for(iCol=0; iCol<pTab->nCol; iCol++){
        if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
          break;
        }
      }
      if( iCol<pTab->nCol ) pTab->aCol[iCol].isPrimKey = 1;


    }
    if( pList->nExpr>1 ) iCol = -1;
  }
  if( iCol>=0 && iCol<pTab->nCol ){
    zType = pTab->aCol[iCol].zType;
  }
  if( zType && sqlite3StrICmp(zType, "INTEGER")==0 ){

    sqlite3VdbeAddOp(v, OP_IsUnique, iIdx, addr2);
    sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, OE_Abort,
                    "indexed columns are not unique", P3_STATIC);
    assert( addr2==sqlite3VdbeCurrentAddr(v) );
  }
  sqlite3VdbeAddOp(v, OP_IdxInsert, iIdx, 0);
  sqlite3VdbeAddOp(v, OP_Next, iTab, addr1+1);
  sqlite3VdbeChangeP2(v, addr1, sqlite3VdbeCurrentAddr(v));
  sqlite3VdbeAddOp(v, OP_Close, iTab, 0);
  sqlite3VdbeAddOp(v, OP_Close, iIdx, 0);
}

/*
** Create a new index for an SQL table.  pName1.pName2 is the name of the index 
** and pTblList is the name of the table that is to be indexed.  Both will 

    zName = sqlite3NameFromToken(pName);
    if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto exit_create_index;
    if( zName==0 ) goto exit_create_index;
    if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
      goto exit_create_index;
    }
    if( !db->init.busy ){
      Index *pISameName;    /* Another index with the same name */
      Table *pTSameName;    /* A table with same name as the index */
      if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto exit_create_index;
      if( (pISameName = sqlite3FindIndex(db, zName, db->aDb[iDb].zName))!=0 ){
        sqlite3ErrorMsg(pParse, "index %s already exists", zName);
        goto exit_create_index;
      }
      if( (pTSameName = sqlite3FindTable(db, zName, 0))!=0 ){
        sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
        goto exit_create_index;
      }
    }
  }else{
    char zBuf[30];
    int n;

  /* 
  ** Allocate the index structure. 
  */
  pIndex = sqliteMalloc( sizeof(Index) + strlen(zName) + 1 + sizeof(int) +
                        (sizeof(int)*2 + sizeof(CollSeq*))*pList->nExpr );
  if( sqlite3_malloc_failed ) goto exit_create_index;
  pIndex->aiColumn = (int*)&pIndex->keyInfo.aColl[pList->nExpr];
  pIndex->aiRowEst = &pIndex->aiColumn[pList->nExpr];
  pIndex->zName = (char*)&pIndex->aiRowEst[pList->nExpr+1];
  strcpy(pIndex->zName, zName);
  pIndex->pTable = pTab;
  pIndex->nColumn = pList->nExpr;
  pIndex->onError = onError;
  pIndex->autoIndex = pName==0;
  pIndex->iDb = iDb;

**           aiRowEst[N]>=1
**
** Apart from that, we have little to go on besides intuition as to
** how aiRowEst[] should be initialized.  The numbers generated here
** are based on typical values found in actual indices.
*/
void sqlite3DefaultRowEst(Index *pIdx){
  int *a = pIdx->aiRowEst;
  int i;
  assert( a!=0 );
  a[0] = 1000000;
  for(i=pIdx->nColumn; i>=1; i--){
    a[i] = 10;
  }
  if( pIdx->onError!=OE_None ){

    destroyRootPage(pParse, pIndex->tnum, iDb);
    sqlite3VdbeOp3(v, OP_DropIndex, iDb, 0, pIndex->zName, 0);
  }

exit_drop_index:
  sqlite3SrcListDelete(pName);
}










































/*
** Append a new element to the given IdList.  Create a new IdList if
** need be.
**
** A new IdList is returned, or NULL if malloc() fails.
*/
IdList *sqlite3IdListAppend(IdList *pList, Token *pToken){

  if( pList==0 ){
    pList = sqliteMalloc( sizeof(IdList) );
    if( pList==0 ) return 0;
    pList->nAlloc = 0;
  }
  if( pList->nId>=pList->nAlloc ){
    struct IdList_item *a;
    pList->nAlloc = pList->nAlloc*2 + 5;
    a = sqliteRealloc(pList->a, pList->nAlloc*sizeof(pList->a[0]) );
    if( a==0 ){
      sqlite3IdListDelete(pList);
      return 0;
    }
    pList->a = a;
  }
  memset(&pList->a[pList->nId], 0, sizeof(pList->a[0]));
  pList->a[pList->nId].zName = sqlite3NameFromToken(pToken);
  pList->nId++;
  return pList;
}

/*
** Delete an IdList.
*/
void sqlite3IdListDelete(IdList *pList){

**    May you share freely, never taking more than you give.
**
*************************************************************************
**
** This file contains functions used to access the internal hash tables
** of user defined functions and collation sequences.
**
** $Id: callback.c,v 1.4 2005/09/01 06:07:55 rmsimpson Exp $
*/

#include "sqliteInt.h"

/*
** Invoke the 'collation needed' callback to request a collation sequence
** in the database text encoding of name zName, length nName.

** An tokenizer for SQL
**
** This file contains C code that implements the sqlite3_complete() API.
** This code used to be part of the tokenizer.c source file.  But by
** separating it out, the code will be automatically omitted from
** static links that do not use it.
**
** $Id: complete.c,v 1.2 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"
#ifndef SQLITE_OMIT_COMPLETE

/*
** This is defined in tokenize.c.  We just have to import the definition.
*/

** This file contains the C functions that implement date and time
** functions for SQLite.  
**
** There is only one exported symbol in this file - the function
** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
** All other code has file scope.
**
** $Id: date.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
**
** NOTES:
**
** SQLite processes all times and dates as Julian Day numbers.  The
** dates and times are stored as the number of days since noon
** in Greenwich on November 24, 4714 B.C. according to the Gregorian
** calendar system.

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains C code routines that are called by the parser
** in order to generate code for DELETE FROM statements.
**
** $Id: delete.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"

/*
** Look up every table that is named in pSrc.  If any table is not found,
** add an error message to pParse->zErrMsg and return NULL.  If all tables
** are found, return a pointer to the last table.

  v = sqlite3GetVdbe(pParse);
  if( v==0 ){
    goto delete_from_cleanup;
  }
  if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
  sqlite3BeginWriteOperation(pParse, triggers_exist, pTab->iDb);

  /* If we are trying to delete from a view, construct that view into
  ** a temporary table.
  */
  if( isView ){
    Select *pView = sqlite3SelectDup(pTab->pSelect);
    sqlite3Select(pParse, pView, SRT_TempTable, iCur, 0, 0, 0, 0);
    sqlite3SelectDelete(pView);
  }

  /* Initialize the counter of the number of rows deleted, if
  ** we are counting rows.
  */
  if( db->flags & SQLITE_CountRows ){

  int iCur,          /* Cursor number for the table */
  int count          /* Increment the row change counter */
){
  int addr;
  addr = sqlite3VdbeAddOp(v, OP_NotExists, iCur, 0);
  sqlite3GenerateRowIndexDelete(db, v, pTab, iCur, 0);
  sqlite3VdbeAddOp(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));
  sqlite3VdbeChangeP2(v, addr, sqlite3VdbeCurrentAddr(v));
}

/*
** This routine generates VDBE code that causes the deletion of all
** index entries associated with a single row of a single table.
**
** The VDBE must be in a particular state when this routine is called.

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains routines used for analyzing expressions and
** for generating VDBE code that evaluates expressions in SQLite.
**
** $Id: expr.c,v 1.15 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>

/*
** Return the 'affinity' of the expression pExpr if any.
**

        break;
      }
    }
    if( i>=pParse->nVarExpr ){
      pExpr->iTable = ++pParse->nVar;
      if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){
        pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10;
        pParse->apVarExpr = sqliteRealloc(pParse->apVarExpr,
                       pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0]) );
      }
      if( !sqlite3_malloc_failed ){
        assert( pParse->apVarExpr!=0 );
        pParse->apVarExpr[pParse->nVarExpr++] = pExpr;
      }
    }

  pNew->pOrderBy = sqlite3ExprListDup(p->pOrderBy);
  pNew->op = p->op;
  pNew->pPrior = sqlite3SelectDup(p->pPrior);
  pNew->pLimit = sqlite3ExprDup(p->pLimit);
  pNew->pOffset = sqlite3ExprDup(p->pOffset);
  pNew->iLimit = -1;
  pNew->iOffset = -1;
  pNew->ppOpenVirtual = 0;
  pNew->isResolved = p->isResolved;
  pNew->isAgg = p->isAgg;






  return pNew;
}
#else
Select *sqlite3SelectDup(Select *p){
  assert( p==0 );
  return 0;
}

    case TK_FUNCTION:
      if( *((int*)pArg)==2 ) return 0;
      /* Fall through */
    case TK_ID:
    case TK_COLUMN:
    case TK_DOT:
    case TK_AGG_FUNCTION:

#ifndef SQLITE_OMIT_SUBQUERY
    case TK_SELECT:
    case TK_EXISTS:
#endif
      *((int*)pArg) = 0;
      return 2;
    case TK_IN:

** If the expression contains aggregate functions then set the EP_Agg
** property on the expression.
*/
int sqlite3ExprResolveNames(
  NameContext *pNC,       /* Namespace to resolve expressions in. */
  Expr *pExpr             /* The expression to be analyzed. */
){

  if( pExpr==0 ) return 0;


  walkExprTree(pExpr, nameResolverStep, pNC);
  if( pNC->nErr>0 ){
    ExprSetProperty(pExpr, EP_Error);





  }
  return ExprHasProperty(pExpr, EP_Error);
}

/*
** A pointer instance of this structure is used to pass information
** through walkExprTree into codeSubqueryStep().

  ** If all of the above are false, then we can run this code just once
  ** save the results, and reuse the same result on subsequent invocations.
  */
  if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->trigStack ){
    int mem = pParse->nMem++;
    sqlite3VdbeAddOp(v, OP_MemLoad, mem, 0);
    testAddr = sqlite3VdbeAddOp(v, OP_If, 0, 0);
    assert( testAddr>0 );
    sqlite3VdbeAddOp(v, OP_Integer, 1, 0);
    sqlite3VdbeAddOp(v, OP_MemStore, mem, 1);
  }

  if( pExpr->pSelect ){
    sqlite3VdbeAddOp(v, OP_AggContextPush, 0, 0);
  }

  switch( pExpr->op ){
    case TK_IN: {
      char affinity;
      KeyInfo keyInfo;
      int addr;        /* Address of OP_OpenVirtual instruction */

          ** disable the test that was generated above that makes sure
          ** this code only executes once.  Because for a non-constant
          ** expression we need to rerun this code each time.
          */
          if( testAddr>0 && !sqlite3ExprIsConstant(pE2) ){
            VdbeOp *aOp = sqlite3VdbeGetOp(v, testAddr-1);
            int i;
            for(i=0; i<4; i++){
              aOp[i].opcode = OP_Noop;
            }
            testAddr = 0;
          }

          /* Evaluate the expression and insert it into the temp table */
          sqlite3ExprCode(pParse, pE2);

                          sqlite3Expr(TK_INTEGER, 0, 0, &one), 0);
      }
      sqlite3Select(pParse, pSel, sop, pExpr->iColumn, 0, 0, 0, 0);
      break;
    }
  }

  if( pExpr->pSelect ){
    sqlite3VdbeAddOp(v, OP_AggContextPop, 0, 0);
  }
  if( testAddr ){
    sqlite3VdbeChangeP2(v, testAddr, sqlite3VdbeCurrentAddr(v));
  }
  return;
}
#endif /* SQLITE_OMIT_SUBQUERY */

/*
** Generate an instruction that will put the integer describe by

  if( v==0 ) return;
  if( pExpr==0 ){
    sqlite3VdbeAddOp(v, OP_Null, 0, 0);
    return;
  }
  op = pExpr->op;
  switch( op ){
    case TK_COLUMN: {

      if( !pParse->fillAgg && pExpr->iAgg>=0 ){

        sqlite3VdbeAddOp(v, OP_AggGet, pExpr->iAggCtx, pExpr->iAgg);









      }else if( pExpr->iColumn>=0 ){
        sqlite3VdbeAddOp(v, OP_Column, pExpr->iTable, pExpr->iColumn);
        sqlite3ColumnDefault(v, pExpr->pTab, pExpr->iColumn);
      }else{
        sqlite3VdbeAddOp(v, OP_Rowid, pExpr->iTable, 0);
      }
      break;
    }

      sqlite3ExprCode(pParse, pExpr->pLeft);
      dest = sqlite3VdbeCurrentAddr(v) + 2;
      sqlite3VdbeAddOp(v, op, 1, dest);
      sqlite3VdbeAddOp(v, OP_AddImm, -1, 0);
      break;
    }
    case TK_AGG_FUNCTION: {

      sqlite3VdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg);
      break;
    }
    case TK_CONST_FUNC:
    case TK_FUNCTION: {
      ExprList *pList = pExpr->pList;
      int nExpr = pList ? pList->nExpr : 0;
      FuncDef *pDef;
      int nId;
      const char *zId;
      int p2 = 0;
      int i;
      u8 enc = pParse->db->enc;
      CollSeq *pColl = 0;
      zId = pExpr->token.z;
      nId = pExpr->token.n;
      pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, enc, 0);
      assert( pDef!=0 );
      nExpr = sqlite3ExprCodeExprList(pParse, pList);
      for(i=0; i<nExpr && i<32; i++){
        if( sqlite3ExprIsConstant(pList->a[i].pExpr) ){
          p2 |= (1<<i);
        }
        if( pDef->needCollSeq && !pColl ){
          pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr);
        }
      }
      if( pDef->needCollSeq ){
        if( !pColl ) pColl = pParse->db->pDfltColl; 
        sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, (char *)pColl, P3_COLLSEQ);
      }
      sqlite3VdbeOp3(v, OP_Function, nExpr, p2, (char*)pDef, P3_FUNCDEF);
      break;
    }
#ifndef SQLITE_OMIT_SUBQUERY
    case TK_EXISTS:
    case TK_SELECT: {
      sqlite3CodeSubselect(pParse, pExpr);
      sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0);

    case TK_AS: {
      sqlite3ExprCode(pParse, pExpr->pLeft);
      break;
    }
    case TK_CASE: {
      int expr_end_label;
      int jumpInst;
      int addr;
      int nExpr;
      int i;
      ExprList *pEList;
      struct ExprList_item *aListelem;

      assert(pExpr->pList);
      assert((pExpr->pList->nExpr % 2) == 0);

                                 OP_Ne, 0, 1);
          sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
        }else{
          jumpInst = sqlite3VdbeAddOp(v, OP_IfNot, 1, 0);
        }
        sqlite3ExprCode(pParse, aListelem[i+1].pExpr);
        sqlite3VdbeAddOp(v, OP_Goto, 0, expr_end_label);
        addr = sqlite3VdbeCurrentAddr(v);
        sqlite3VdbeChangeP2(v, jumpInst, addr);
      }
      if( pExpr->pLeft ){
        sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
      }
      if( pExpr->pRight ){
        sqlite3ExprCode(pParse, pExpr->pRight);
      }else{

      addr = codeCompare(pParse, pLeft, pRight, OP_Lt, 0, !jumpIfNull);

      pRight = pExpr->pList->a[1].pExpr;
      sqlite3ExprCode(pParse, pRight);
      codeCompare(pParse, pLeft, pRight, OP_Le, dest, jumpIfNull);

      sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
      sqlite3VdbeChangeP2(v, addr, sqlite3VdbeCurrentAddr(v));
      sqlite3VdbeAddOp(v, OP_Pop, 1, 0);
      break;
    }
    default: {
      sqlite3ExprCode(pParse, pExpr);
      sqlite3VdbeAddOp(v, OP_If, jumpIfNull, dest);
      break;

  int i;
  if( pA==0 ){
    return pB==0;
  }else if( pB==0 ){
    return 0;
  }
  if( pA->op!=pB->op ) return 0;

  if( !sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 0;
  if( !sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 0;
  if( pA->pList ){
    if( pB->pList==0 ) return 0;
    if( pA->pList->nExpr!=pB->pList->nExpr ) return 0;
    for(i=0; i<pA->pList->nExpr; i++){
      if( !sqlite3ExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){

    if( pB->token.z==0 ) return 0;
    if( pB->token.n!=pA->token.n ) return 0;
    if( sqlite3StrNICmp(pA->token.z, pB->token.z, pB->token.n)!=0 ) return 0;
  }
  return 1;
}


/*
** Add a new element to the pParse->aAgg[] array and return its index.
** The new element is initialized to zero.  The calling function is
** expected to fill it in.
*/
static int appendAggInfo(Parse *pParse){
  if( (pParse->nAgg & 0x7)==0 ){
    int amt = pParse->nAgg + 8;
    AggExpr *aAgg = sqliteRealloc(pParse->aAgg, amt*sizeof(pParse->aAgg[0]));
    if( aAgg==0 ){
      return -1;
    }
    pParse->aAgg = aAgg;

  }
  memset(&pParse->aAgg[pParse->nAgg], 0, sizeof(pParse->aAgg[0]));










  return pParse->nAgg++;
}

/*
** This is an xFunc for walkExprTree() used to implement 
** sqlite3ExprAnalyzeAggregates().  See sqlite3ExprAnalyzeAggregates
** for additional information.
**
** This routine analyzes the aggregate function at pExpr.
*/
static int analyzeAggregate(void *pArg, Expr *pExpr){
  int i;
  AggExpr *aAgg;
  NameContext *pNC = (NameContext *)pArg;
  Parse *pParse = pNC->pParse;
  SrcList *pSrcList = pNC->pSrcList;



  switch( pExpr->op ){
    case TK_COLUMN: {




      for(i=0; pSrcList && i<pSrcList->nSrc; i++){

        if( pExpr->iTable==pSrcList->a[i].iCursor ){






          aAgg = pParse->aAgg;
          for(i=0; i<pParse->nAgg; i++){
            if( aAgg[i].isAgg ) continue;
            if( aAgg[i].pExpr->iTable==pExpr->iTable
             && aAgg[i].pExpr->iColumn==pExpr->iColumn ){
              break;
            }
          }
          if( i>=pParse->nAgg ){
            i = appendAggInfo(pParse);
            if( i<0 ) return 1;


            pParse->aAgg[i].isAgg = 0;

            pParse->aAgg[i].pExpr = pExpr;











          }











          pExpr->iAgg = i;

          pExpr->iAggCtx = pNC->nDepth;
          return 1;
        }


      }
      return 1;
    }
    case TK_AGG_FUNCTION: {


      if( pNC->nDepth==0 ){
        aAgg = pParse->aAgg;




        for(i=0; i<pParse->nAgg; i++){
          if( !aAgg[i].isAgg ) continue;
          if( sqlite3ExprCompare(aAgg[i].pExpr, pExpr) ){
            break;
          }
        }
        if( i>=pParse->nAgg ){


          u8 enc = pParse->db->enc;
          i = appendAggInfo(pParse);
          if( i<0 ) return 1;
          pParse->aAgg[i].isAgg = 1;
          pParse->aAgg[i].pExpr = pExpr;

          pParse->aAgg[i].pFunc = sqlite3FindFunction(pParse->db,
               pExpr->token.z, pExpr->token.n,
               pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0);




        }




        pExpr->iAgg = i;

        return 1;
      }
    }
  }





  if( pExpr->pSelect ){
    pNC->nDepth++;
    walkSelectExpr(pExpr->pSelect, analyzeAggregate, pNC);
    pNC->nDepth--;
  }
  return 0;
}

** the number of errors.
*/
int sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
  int nErr = pNC->pParse->nErr;
  walkExprTree(pExpr, analyzeAggregate, pNC);
  return pNC->pParse->nErr - nErr;
}

** This file contains the C functions that implement various SQL
** functions of SQLite.  
**
** There is only one exported symbol in this file - the function
** sqliteRegisterBuildinFunctions() found at the bottom of the file.
** All other code has file scope.
**
** $Id: func.c,v 1.9 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
#include <math.h>
#include <stdlib.h>
#include <assert.h>
#include "vdbeInt.h"

** An instance of the following structure holds the context of a
** sum() or avg() aggregate computation.
*/
typedef struct SumCtx SumCtx;
struct SumCtx {
  double sum;     /* Sum of terms */
  int cnt;        /* Number of elements summed */

};

/*
** Routines used to compute the sum or average.
*/
static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
  SumCtx *p;

  if( argc<1 ) return;
  p = sqlite3_aggregate_context(context, sizeof(*p));
  if( p && SQLITE_NULL!=sqlite3_value_type(argv[0]) ){

    p->sum += sqlite3_value_double(argv[0]);
    p->cnt++;



  }
}
static void sumFinalize(sqlite3_context *context){
  SumCtx *p;
  p = sqlite3_aggregate_context(context, sizeof(*p));


  sqlite3_result_double(context, p ? p->sum : 0.0);




}
static void avgFinalize(sqlite3_context *context){
  SumCtx *p;
  p = sqlite3_aggregate_context(context, sizeof(*p));
  if( p && p->cnt>0 ){
    sqlite3_result_double(context, p->sum/(double)p->cnt);
  }
}

/*
** An instance of the following structure holds the context of a

  p = sqlite3_aggregate_context(context, sizeof(*p));
  if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
    p->n++;
  }
}   
static void countFinalize(sqlite3_context *context){
  CountCtx *p;
  p = sqlite3_aggregate_context(context, sizeof(*p));
  sqlite3_result_int(context, p ? p->n : 0);
}

/*
** Routines to implement min() and max() aggregate functions.
*/
static void minmaxStep(sqlite3_context *context, int argc, sqlite3_value **argv){

    }
  }else{
    sqlite3VdbeMemCopy(pBest, pArg);
  }
}
static void minMaxFinalize(sqlite3_context *context){
  sqlite3_value *pRes;
  pRes = (sqlite3_value *)sqlite3_aggregate_context(context, sizeof(Mem));

  if( pRes->flags ){
    sqlite3_result_value(context, pRes);
  }
  sqlite3VdbeMemRelease(pRes);

}


/*
** This function registered all of the above C functions as SQL
** functions.  This should be the only routine in this file with
** external linkage.

  sqlite3RegisterLikeFunctions(db, 0);
#endif
}

/*
** Set the LIKEOPT flag on the 2-argument function with the given name.
*/
static void setLikeOptFlag(sqlite3 *db, const char *zName){
  FuncDef *pDef;
  pDef = sqlite3FindFunction(db, zName, strlen(zName), 2, SQLITE_UTF8, 0);
  if( pDef ){
    pDef->flags = SQLITE_FUNC_LIKEOPT;
  }
}

/*
** Register the built-in LIKE and GLOB functions.  The caseSensitive
** parameter determines whether or not the LIKE operator is case
** sensitive.  GLOB is always case sensitive.
*/
void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
  struct compareInfo *pInfo;
  if( caseSensitive ){
    pInfo = (struct compareInfo*)&likeInfoAlt;
  }else{
    pInfo = (struct compareInfo*)&likeInfoNorm;
  }
  sqlite3_create_function(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
  sqlite3_create_function(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0);
  sqlite3_create_function(db, "glob", 2, SQLITE_UTF8, 
      (struct compareInfo*)&globInfo, likeFunc, 0,0);
  setLikeOptFlag(db, "glob");
  if( caseSensitive ){
    setLikeOptFlag(db, "like");
  }

}

/*
** pExpr points to an expression which implements a function.  If
** it is appropriate to apply the LIKE optimization to that function
** then set aWc[0] through aWc[2] to the wildcard characters and
** return TRUE.  If the function is not a LIKE-style function then
** return FALSE.
*/
int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, char *aWc){
  FuncDef *pDef;
  if( pExpr->op!=TK_FUNCTION ){
    return 0;
  }
  if( pExpr->pList->nExpr!=2 ){
    return 0;
  }
  pDef = sqlite3FindFunction(db, pExpr->token.z, pExpr->token.n, 2,
                             SQLITE_UTF8, 0);
  if( pDef==0 || (pDef->flags & SQLITE_FUNC_LIKEOPT)==0 ){
    return 0;
  }

  /* The memcpy() statement assumes that the wildcard characters are
  ** the first three statements in the compareInfo structure.  The
  ** asserts() that follow verify that assumption
  */
  memcpy(aWc, pDef->pUserData, 3);
  assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
  assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
  assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );

  return 1;
}

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This is the implementation of generic hash-tables
** used in SQLite.
**
** $Id: hash.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include <assert.h>

/* Turn bulk memory into a hash table object by initializing the
** fields of the Hash structure.
**

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This is the header file for the generic hash-table implemenation
** used in SQLite.
**
** $Id: hash.h,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/
#ifndef _SQLITE_HASH_H_
#define _SQLITE_HASH_H_

/* Forward declarations of structures. */
typedef struct Hash Hash;
typedef struct HashElem HashElem;

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains C code routines that are called by the parser
** to handle INSERT statements in SQLite.
**
** $Id: insert.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"

/*
** Set P3 of the most recently inserted opcode to a column affinity
** string for index pIdx. A column affinity string has one character
** for each column in the table, according to the affinity of the column:

      sqlite3VdbeAddOp(v, OP_Insert, srcTab, 0);
      sqlite3VdbeAddOp(v, OP_Return, 0, 0);

      /* The following code runs first because the GOTO at the very top
      ** of the program jumps to it.  Create the temporary table, then jump
      ** back up and execute the SELECT code above.
      */
      sqlite3VdbeChangeP2(v, iInitCode, sqlite3VdbeCurrentAddr(v));
      sqlite3VdbeAddOp(v, OP_OpenVirtual, srcTab, 0);
      sqlite3VdbeAddOp(v, OP_SetNumColumns, srcTab, nColumn);
      sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop);
      sqlite3VdbeResolveLabel(v, iCleanup);
    }else{
      sqlite3VdbeChangeP2(v, iInitCode, sqlite3VdbeCurrentAddr(v));
    }
  }else{
    /* This is the case if the data for the INSERT is coming from a VALUES
    ** clause
    */
    NameContext sNC;
    memset(&sNC, 0, sizeof(sNC));

    sqlite3VdbeAddOp(v, OP_SetNumColumns, newIdx, pTab->nCol);
  }
    
  /* Initialize the count of rows to be inserted
  */
  if( db->flags & SQLITE_CountRows ){
    iCntMem = pParse->nMem++;
    sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
    sqlite3VdbeAddOp(v, OP_MemStore, iCntMem, 1);
  }

  /* Open tables and indices if there are no row triggers */
  if( !triggers_exist ){
    base = pParse->nTab;
    sqlite3OpenTableAndIndices(pParse, pTab, base, OP_OpenWrite);
  }

  int onError;
  int addr;
  int extra;
  int iCur;
  Index *pIdx;
  int seenReplace = 0;
  int jumpInst1=0, jumpInst2;
  int contAddr;
  int hasTwoRowids = (isUpdate && rowidChng);

  v = sqlite3GetVdbe(pParse);
  assert( v!=0 );
  assert( pTab->pSelect==0 );  /* This table is not a VIEW */
  nCol = pTab->nCol;

      }
      case OE_Replace: {
        sqlite3ExprCode(pParse, pTab->aCol[i].pDflt);
        sqlite3VdbeAddOp(v, OP_Push, nCol-i, 0);
        break;
      }
    }
    sqlite3VdbeChangeP2(v, addr, sqlite3VdbeCurrentAddr(v));
  }

  /* Test all CHECK constraints
  */
  /**** TBD ****/

  /* If we have an INTEGER PRIMARY KEY, make sure the primary key

      case OE_Ignore: {
        assert( seenReplace==0 );
        sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0);
        sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest);
        break;
      }
    }
    contAddr = sqlite3VdbeCurrentAddr(v);
    sqlite3VdbeChangeP2(v, jumpInst2, contAddr);
    if( isUpdate ){
      sqlite3VdbeChangeP2(v, jumpInst1, contAddr);
      sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1);
      sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);
    }
  }

  /* Test all UNIQUE constraints by creating entries for each UNIQUE
  ** index and making sure that duplicate entries do not already exist.

          sqlite3VdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRowids, 1);
          sqlite3VdbeAddOp(v, OP_MoveGe, base, 0);
        }
        seenReplace = 1;
        break;
      }
    }
    contAddr = sqlite3VdbeCurrentAddr(v);
#if NULL_DISTINCT_FOR_UNIQUE
    sqlite3VdbeChangeP2(v, jumpInst1, contAddr);
#endif
    sqlite3VdbeChangeP2(v, jumpInst2, contAddr);
  }
}

/*
** This routine generates code to finish the INSERT or UPDATE operation
** that was started by a prior call to sqlite3GenerateConstraintChecks.
** The stack must contain keys for all active indices followed by data

/* Hash score: 156 */
static int keywordCode(const char *z, int n){
  static const char zText[526] =
    "ABORTABLEFTEMPORARYADDATABASELECTHENDEFAULTRANSACTIONATURALTER"
    "AISEACHECKEYAFTEREFERENCESCAPELSEXCEPTRIGGEREGEXPLAINITIALLYANALYZE"
    "XCLUSIVEXISTSTATEMENTANDEFERRABLEATTACHAVINGLOBEFOREIGNOREINDEX"
    "AUTOINCREMENTBEGINNERENAMEBETWEENOTNULLIKEBYCASCADEFERREDELETE"
    "CASECASTCOLLATECOLUMNCOMMITCONFLICTCONSTRAINTERSECTCREATECROSS"
    "CURRENT_DATECURRENT_TIMESTAMPRAGMATCHDESCDETACHDISTINCTDROPRIMARY"
    "FAILIMITFROMFULLGROUPDATEIMMEDIATEINSERTINSTEADINTOFFSETISNULL"
    "JOINORDEREPLACEOUTERESTRICTRIGHTROLLBACKROWHENUNIONUNIQUEUSING"
    "VACUUMVALUESVIEWHERE";
  static const unsigned char aHash[127] = {
      91,  81, 104,  90,   0,   4,   0,   0, 111,   0,  77,   0,   0,
      94,  44,   0,  92,   0, 103, 106,  96,   0,   0,  10,   0,   0,
     110,   0, 107, 102,   0,  28,  48,   0,  41,   0,   0,  65,  71,
       0,  63,  19,   0,   0,  36,  83,   0, 105,  74,   0,   0,  33,
       0,  61,  37,   0,   8,   0, 112,  38,  12,   0,  78,  40,  25,
      66,   0,   0,  31,  82,  53,  30,  50,  20,  88,   0,  34,   0,
      75,  26,   0,  72,   0,   0,   0,  64,  47,  67,  22,  87,  29,
      69,  86,   0,   1,   0,   9, 100,  58,  18,   0, 109,  76,  98,
      54,   6,  85,   0,   0,  49,  93,   0, 101,   0,  70,   0,   0,
      15,   0, 113,  51,  56,   0,   2,  55,   0, 108,
  };
  static const unsigned char aNext[113] = {
       0,   0,   0,   0,   0,   3,   0,   0,   0,   0,   0,   0,   0,
       0,   0,   0,   0,   0,   0,   0,   0,  17,   0,   0,   0,   0,
       0,  11,   0,   0,   0,   0,   5,  13,   0,   7,   0,   0,   0,
       0,   0,   0,   0,   0,   0,   0,  43,   0,   0,   0,   0,   0,
       0,   0,  16,   0,  23,  52,   0,   0,   0,   0,  45,   0,  59,
       0,   0,   0,   0,   0,   0,   0,   0,  73,  42,   0,   0,  24,
      60,  21,   0,  80,  32,  68,   0,   0,  84,  46,   0,   0,   0,
       0,   0,   0,   0,  39,  95,  97,   0,   0,  99,   0,  14,  27,
      79,   0,  57,  89,   0,  35,   0,  62,   0,
  };
  static const unsigned char aLen[113] = {
       5,   5,   4,   4,   9,   2,   3,   8,   2,   6,   4,   3,   7,
      11,   2,   7,   5,   5,   4,   5,   3,   5,  10,   6,   4,   6,
       7,   6,   7,   9,   3,   7,   9,   6,   9,   3,  10,   6,   6,
       4,   6,   3,   7,   6,   7,   5,  13,   2,   2,   5,   5,   6,
       7,   3,   7,   4,   4,   2,   7,   3,   8,   6,   4,   4,   7,
       6,   6,   8,  10,   9,   6,   5,  12,  12,  17,   6,   5,   4,
       6,   8,   2,   4,   7,   4,   5,   4,   4,   5,   6,   9,   6,
       7,   4,   2,   6,   3,   6,   4,   5,   7,   5,   8,   5,   8,
       3,   4,   5,   6,   5,   6,   6,   4,   5,
  };
  static const unsigned short int aOffset[113] = {
       0,   4,   7,  10,  10,  14,  19,  21,  26,  27,  32,  34,  36,
      42,  51,  52,  57,  61,  65,  67,  71,  74,  78,  86,  91,  94,
      99, 105, 108, 113, 118, 122, 128, 136, 141, 150, 152, 162, 167,
     172, 175, 177, 177, 181, 185, 187, 192, 194, 196, 205, 208, 212,
     218, 224, 224, 227, 230, 234, 236, 237, 241, 248, 254, 258, 262,
     269, 275, 281, 289, 296, 305, 311, 316, 328, 328, 344, 348, 353,
     357, 363, 364, 371, 374, 381, 384, 389, 393, 397, 400, 406, 415,
     421, 428, 431, 431, 434, 437, 443, 447, 451, 458, 462, 470, 475,
     483, 485, 489, 494, 500, 505, 511, 517, 520,
  };
  static const unsigned char aCode[113] = {
    TK_ABORT,      TK_TABLE,      TK_JOIN_KW,    TK_TEMP,       TK_TEMP,       
    TK_OR,         TK_ADD,        TK_DATABASE,   TK_AS,         TK_SELECT,     
    TK_THEN,       TK_END,        TK_DEFAULT,    TK_TRANSACTION,TK_ON,         
    TK_JOIN_KW,    TK_ALTER,      TK_RAISE,      TK_EACH,       TK_CHECK,      
    TK_KEY,        TK_AFTER,      TK_REFERENCES, TK_ESCAPE,     TK_ELSE,       
    TK_EXCEPT,     TK_TRIGGER,    TK_LIKE_KW,    TK_EXPLAIN,    TK_INITIALLY,  
    TK_ALL,        TK_ANALYZE,    TK_EXCLUSIVE,  TK_EXISTS,     TK_STATEMENT,  
    TK_AND,        TK_DEFERRABLE, TK_ATTACH,     TK_HAVING,     TK_LIKE_KW,    
    TK_BEFORE,     TK_FOR,        TK_FOREIGN,    TK_IGNORE,     TK_REINDEX,    
    TK_INDEX,      TK_AUTOINCR,   TK_TO,         TK_IN,         TK_BEGIN,      
    TK_JOIN_KW,    TK_RENAME,     TK_BETWEEN,    TK_NOT,        TK_NOTNULL,    
    TK_NULL,       TK_LIKE_KW,    TK_BY,         TK_CASCADE,    TK_ASC,        
    TK_DEFERRED,   TK_DELETE,     TK_CASE,       TK_CAST,       TK_COLLATE,    
    TK_COLUMNKW,   TK_COMMIT,     TK_CONFLICT,   TK_CONSTRAINT, TK_INTERSECT,  
    TK_CREATE,     TK_JOIN_KW,    TK_CTIME_KW,   TK_CTIME_KW,   TK_CTIME_KW,   
    TK_PRAGMA,     TK_MATCH,      TK_DESC,       TK_DETACH,     TK_DISTINCT,   
    TK_IS,         TK_DROP,       TK_PRIMARY,    TK_FAIL,       TK_LIMIT,      
    TK_FROM,       TK_JOIN_KW,    TK_GROUP,      TK_UPDATE,     TK_IMMEDIATE,  
    TK_INSERT,     TK_INSTEAD,    TK_INTO,       TK_OF,         TK_OFFSET,     
    TK_SET,        TK_ISNULL,     TK_JOIN,       TK_ORDER,      TK_REPLACE,    
    TK_JOIN_KW,    TK_RESTRICT,   TK_JOIN_KW,    TK_ROLLBACK,   TK_ROW,        
    TK_WHEN,       TK_UNION,      TK_UNIQUE,     TK_USING,      TK_VACUUM,     
    TK_VALUES,     TK_VIEW,       TK_WHERE,      
  };
  int h, i;
  if( n<2 ) return TK_ID;
  h = ((sqlite3UpperToLower[((unsigned char*)z)[0]]*4) ^
      (sqlite3UpperToLower[((unsigned char*)z)[n-1]]*3) ^
      n) % 127;
  for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){

**
*************************************************************************
** Main file for the SQLite library.  The routines in this file
** implement the programmer interface to the library.  Routines in
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
** $Id: legacy.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/

#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>

/*

**
*************************************************************************
** Main file for the SQLite library.  The routines in this file
** implement the programmer interface to the library.  Routines in
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
** $Id: main.c,v 1.8 2005/09/01 06:07:55 rmsimpson Exp $
*/
#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>

/*
** The following constant value is used by the SQLITE_BIGENDIAN and

  }
  rc = sqlite3_create_function(db, zFunc8, nArg, eTextRep, 
      pUserData, xFunc, xStep, xFinal);
  return rc;
}
#endif


/*
** Register a trace function.  The pArg from the previously registered trace
** is returned.  
**
** A NULL trace function means that no tracing is executes.  A non-NULL
** trace is a pointer to a function that is invoked at the start of each
** sqlite3_exec().
*/
void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
  void *pOld = db->pTraceArg;
  db->xTrace = xTrace;
  db->pTraceArg = pArg;
  return pOld;
}




















/*** EXPERIMENTAL ***
**
** Register a function to be invoked when a transaction comments.
** If either function returns non-zero, then the commit becomes a
** rollback.
*/

*/
static int openDatabase(
  const char *zFilename, /* Database filename UTF-8 encoded */
  sqlite3 **ppDb         /* OUT: Returned database handle */
){
  sqlite3 *db;
  int rc, i;


  /* Allocate the sqlite data structure */
  db = sqliteMalloc( sizeof(sqlite3) );
  if( db==0 ) goto opendb_out;
  db->priorNewRowid = 0;
  db->magic = SQLITE_MAGIC_BUSY;
  db->nDb = 2;

    assert( rc!=SQLITE_OK );
    db->magic = SQLITE_MAGIC_CLOSED;
    goto opendb_out;
  }

  /* Also add a UTF-8 case-insensitive collation sequence. */
  sqlite3_create_collation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc);








  /* Open the backend database driver */
  rc = sqlite3BtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt);
  if( rc!=SQLITE_OK ){
    sqlite3Error(db, rc, 0);
    db->magic = SQLITE_MAGIC_CLOSED;
    goto opendb_out;

*/
int sqlite3_reset(sqlite3_stmt *pStmt){
  int rc;
  if( pStmt==0 ){
    rc = SQLITE_OK;
  }else{
    rc = sqlite3VdbeReset((Vdbe*)pStmt);
    sqlite3VdbeMakeReady((Vdbe*)pStmt, -1, 0, 0, 0, 0);
  }
  return rc;
}

/*
** Register a new collation sequence with the database handle db.
*/

      return SQLITE_BUSY;
    }
    sqlite3ExpirePreparedStatements(db);
  }

  pColl = sqlite3FindCollSeq(db, (u8)enc, zName, strlen(zName), 1);
  if( 0==pColl ){
   rc = SQLITE_NOMEM;
  }else{
    pColl->xCmp = xCompare;
    pColl->pUser = pCtx;
    pColl->enc = enc;
  }
  sqlite3Error(db, rc, 0);
  return rc;

** by the next COMMIT or ROLLBACK.
**
******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
*/
int sqlite3_get_autocommit(sqlite3 *db){
  return db->autoCommit;
}

/* Automatically generated.  Do not edit */
/* See the mkopcodec.awk script for details. */
#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
const char *const sqlite3OpcodeNames[] = { "?",
 /*   1 */ "MemLoad",
 /*   2 */ "Column",
 /*   3 */ "SetCookie",
 /*   4 */ "IfMemPos",
 /*   5 */ "MoveGt",
 /*   6 */ "AggFocus",
 /*   7 */ "RowKey",
 /*   8 */ "AggNext",
 /*   9 */ "OpenWrite",
 /*  10 */ "If",
 /*  11 */ "ToInt",
 /*  12 */ "Pop",
 /*  13 */ "AggContextPush",
 /*  14 */ "CollSeq",
 /*  15 */ "OpenRead",
 /*  16 */ "Expire",
 /*  17 */ "SortReset",
 /*  18 */ "AutoCommit",
 /*  19 */ "Sort",
 /*  20 */ "IntegrityCk",
 /*  21 */ "SortInsert",
 /*  22 */ "Function",
 /*  23 */ "Noop",
 /*  24 */ "Return",
 /*  25 */ "NewRowid",
 /*  26 */ "Variable",
 /*  27 */ "String",
 /*  28 */ "ParseSchema",
 /*  29 */ "AggFunc",
 /*  30 */ "Close",
 /*  31 */ "CreateIndex",
 /*  32 */ "IsUnique",
 /*  33 */ "IdxIsNull",
 /*  34 */ "NotFound",
 /*  35 */ "Int64",
 /*  36 */ "MustBeInt",
 /*  37 */ "Halt",
 /*  38 */ "Rowid",
 /*  39 */ "IdxLT",
 /*  40 */ "AddImm",
 /*  41 */ "Statement",
 /*  42 */ "RowData",
 /*  43 */ "MemMax",
 /*  44 */ "Push",
 /*  45 */ "NotExists",
 /*  46 */ "MemIncr",
 /*  47 */ "Gosub",
 /*  48 */ "AggSet",
 /*  49 */ "Integer",
 /*  50 */ "ToNumeric",
 /*  51 */ "SortNext",
 /*  52 */ "Prev",
 /*  53 */ "CreateTable",
 /*  54 */ "Last",
 /*  55 */ "IdxRowid",
 /*  56 */ "MakeIdxRec",
 /*  57 */ "ResetCount",
 /*  58 */ "FifoWrite",
 /*  59 */ "Callback",
 /*  60 */ "ContextPush",
 /*  61 */ "DropTrigger",
 /*  62 */ "DropIndex",
 /*  63 */ "IdxGE",
 /*  64 */ "Or",
 /*  65 */ "And",
 /*  66 */ "Not",
 /*  67 */ "IdxDelete",
 /*  68 */ "Vacuum",
 /*  69 */ "MoveLe",
 /*  70 */ "IsNull",
 /*  71 */ "NotNull",
 /*  72 */ "Ne",
 /*  73 */ "Eq",
 /*  74 */ "Gt",
 /*  75 */ "Le",
 /*  76 */ "Lt",
 /*  77 */ "Ge",
 /*  78 */ "IfNot",
 /*  79 */ "BitAnd",
 /*  80 */ "BitOr",
 /*  81 */ "ShiftLeft",
 /*  82 */ "ShiftRight",
 /*  83 */ "Add",
 /*  84 */ "Subtract",
 /*  85 */ "Multiply",
 /*  86 */ "Divide",
 /*  87 */ "Remainder",
 /*  88 */ "Concat",
 /*  89 */ "Negative",
 /*  90 */ "DropTable",
 /*  91 */ "BitNot",
 /*  92 */ "String8",
 /*  93 */ "MakeRecord",
 /*  94 */ "ToBlob",
 /*  95 */ "Delete",
 /*  96 */ "AggContextPop",
 /*  97 */ "Dup",
 /*  98 */ "Goto",
 /*  99 */ "FifoRead",
 /* 100 */ "Clear",
 /* 101 */ "IdxGT",
 /* 102 */ "MoveLt",
 /* 103 */ "VerifyCookie",
 /* 104 */ "Pull",
 /* 105 */ "ToText",
 /* 106 */ "SetNumColumns",
 /* 107 */ "AbsValue",





 /* 108 */ "Transaction",
 /* 109 */ "AggGet",
 /* 110 */ "ContextPop",
 /* 111 */ "Next",
 /* 112 */ "AggInit",
 /* 113 */ "IdxInsert",
 /* 114 */ "Distinct",
 /* 115 */ "AggReset",
 /* 116 */ "Insert",
 /* 117 */ "Destroy",
 /* 118 */ "ReadCookie",
 /* 119 */ "ForceInt",
 /* 120 */ "LoadAnalysis",
 /* 121 */ "OpenVirtual",
 /* 122 */ "OpenPseudo",
 /* 123 */ "Null",
 /* 124 */ "Blob",
 /* 125 */ "MemStore",
 /* 126 */ "Rewind",
 /* 127 */ "MoveGe",
 /* 128 */ "Found",
 /* 129 */ "NullRow",
 /* 130 */ "Real",
 /* 131 */ "HexBlob",



};
#endif

/* Automatically generated.  Do not edit */
/* See the mkopcodeh.awk script for details */
#define OP_MemLoad                              1
#define OP_HexBlob                            131   /* same as TK_BLOB     */
#define OP_Column                               2
#define OP_SetCookie                            3
#define OP_IfMemPos                             4
#define OP_Real                               130   /* same as TK_FLOAT    */

#define OP_MoveGt                               5
#define OP_Ge                                  77   /* same as TK_GE       */
#define OP_AggFocus                             6
#define OP_RowKey                               7
#define OP_AggNext                              8
#define OP_Eq                                  73   /* same as TK_EQ       */
#define OP_OpenWrite                            9
#define OP_NotNull                             71   /* same as TK_NOTNULL  */
#define OP_If                                  10
#define OP_ToInt                               11
#define OP_String8                             92   /* same as TK_STRING   */
#define OP_Pop                                 12
#define OP_AggContextPush                      13
#define OP_CollSeq                             14
#define OP_OpenRead                            15
#define OP_Expire                              16
#define OP_SortReset                           17
#define OP_AutoCommit                          18
#define OP_Gt                                  74   /* same as TK_GT       */
#define OP_Sort                                19
#define OP_IntegrityCk                         20
#define OP_SortInsert                          21
#define OP_Function                            22
#define OP_And                                 65   /* same as TK_AND      */
#define OP_Subtract                            84   /* same as TK_MINUS    */
#define OP_Noop                                23
#define OP_Return                              24
#define OP_Remainder                           87   /* same as TK_REM      */
#define OP_NewRowid                            25
#define OP_Multiply                            85   /* same as TK_STAR     */
#define OP_Variable                            26
#define OP_String                              27
#define OP_ParseSchema                         28
#define OP_AggFunc                             29
#define OP_Close                               30
#define OP_CreateIndex                         31
#define OP_IsUnique                            32
#define OP_IdxIsNull                           33
#define OP_NotFound                            34
#define OP_Int64                               35
#define OP_MustBeInt                           36
#define OP_Halt                                37
#define OP_Rowid                               38
#define OP_IdxLT                               39
#define OP_AddImm                              40
#define OP_Statement                           41
#define OP_RowData                             42
#define OP_MemMax                              43
#define OP_Push                                44
#define OP_Or                                  64   /* same as TK_OR       */
#define OP_NotExists                           45
#define OP_MemIncr                             46
#define OP_Gosub                               47
#define OP_Divide                              86   /* same as TK_SLASH    */
#define OP_AggSet                              48
#define OP_Integer                             49
#define OP_ToNumeric                           50
#define OP_SortNext                            51
#define OP_Prev                                52
#define OP_Concat                              88   /* same as TK_CONCAT   */
#define OP_BitAnd                              79   /* same as TK_BITAND   */
#define OP_CreateTable                         53
#define OP_Last                                54
#define OP_IsNull                              70   /* same as TK_ISNULL   */
#define OP_IdxRowid                            55
#define OP_MakeIdxRec                          56
#define OP_ShiftRight                          82   /* same as TK_RSHIFT   */
#define OP_ResetCount                          57
#define OP_FifoWrite                           58
#define OP_Callback                            59
#define OP_ContextPush                         60
#define OP_DropTrigger                         61
#define OP_DropIndex                           62
#define OP_IdxGE                               63
#define OP_IdxDelete                           67
#define OP_Vacuum                              68
#define OP_MoveLe                              69
#define OP_IfNot                               78
#define OP_DropTable                           90
#define OP_MakeRecord                          93
#define OP_ToBlob                              94
#define OP_Delete                              95
#define OP_AggContextPop                       96
#define OP_ShiftLeft                           81   /* same as TK_LSHIFT   */
#define OP_Dup                                 97
#define OP_Goto                                98
#define OP_FifoRead                            99
#define OP_Clear                              100
#define OP_IdxGT                              101
#define OP_MoveLt                             102
#define OP_Le                                  75   /* same as TK_LE       */
#define OP_VerifyCookie                       103

#define OP_Pull                               104
#define OP_ToText                             105
#define OP_Not                                 66   /* same as TK_NOT      */
#define OP_SetNumColumns                      106
#define OP_AbsValue                           107
#define OP_Transaction                        108
#define OP_Negative                            89   /* same as TK_UMINUS   */
#define OP_Ne                                  72   /* same as TK_NE       */
#define OP_AggGet                             109
#define OP_ContextPop                         110
#define OP_BitOr                               80   /* same as TK_BITOR    */
#define OP_Next                               111
#define OP_AggInit                            112
#define OP_IdxInsert                          113
#define OP_Distinct                           114
#define OP_Lt                                  76   /* same as TK_LT       */
#define OP_AggReset                           115
#define OP_Insert                             116
#define OP_Destroy                            117
#define OP_ReadCookie                         118
#define OP_ForceInt                           119
#define OP_LoadAnalysis                       120
#define OP_OpenVirtual                        121

#define OP_OpenPseudo                         122
#define OP_Null                               123
#define OP_Blob                               124
#define OP_Add                                 83   /* same as TK_PLUS     */
#define OP_MemStore                           125
#define OP_Rewind                             126
#define OP_MoveGe                             127
#define OP_BitNot                              91   /* same as TK_BITNOT   */


#define OP_Found                              128
#define OP_NullRow                            129











#define NOPUSH_MASK_0 65400
#define NOPUSH_MASK_1 29103
#define NOPUSH_MASK_2 64439
#define NOPUSH_MASK_3 65109
#define NOPUSH_MASK_4 65535
#define NOPUSH_MASK_5 52991
#define NOPUSH_MASK_6 55285
#define NOPUSH_MASK_7 59295
#define NOPUSH_MASK_8 3
#define NOPUSH_MASK_9 0

** Changing the value of PENDING_BYTE results in a subtly incompatible
** file format.  Depending on how it is changed, you might not notice
** the incompatibility right away, even running a full regression test.
** The default location of PENDING_BYTE is the first byte past the
** 1GB boundary.
**
*/

#define PENDING_BYTE      0x40000000  /* First byte past the 1GB boundary */


/* #define PENDING_BYTE     0x5400   // Page 22 - for testing */


#define RESERVED_BYTE     (PENDING_BYTE+1)
#define SHARED_FIRST      (PENDING_BYTE+2)
#define SHARED_SIZE       510


int sqlite3OsDelete(const char*);
int sqlite3OsFileExists(const char*);
int sqlite3OsOpenReadWrite(const char*, OsFile*, int*);
int sqlite3OsOpenExclusive(const char*, OsFile*, int);
int sqlite3OsOpenReadOnly(const char*, OsFile*);
int sqlite3OsOpenDirectory(const char*, OsFile*);
int sqlite3OsSyncDirectory(const char*);
int sqlite3OsTempFileName(char*);
int sqlite3OsIsDirWritable(char*);
int sqlite3OsClose(OsFile*);
int sqlite3OsRead(OsFile*, void*, int amt);
int sqlite3OsWrite(OsFile*, const void*, int amt);
int sqlite3OsSeek(OsFile*, i64 offset);
int sqlite3OsSync(OsFile*);
int sqlite3OsTruncate(OsFile*, i64 size);
int sqlite3OsFileSize(OsFile*, i64 *pSize);
char *sqlite3OsFullPathname(const char*);
int sqlite3OsLock(OsFile*, int);
int sqlite3OsUnlock(OsFile*, int);
int sqlite3OsCheckReservedLock(OsFile *id);

** switch.  The following code should catch this problem at compile-time.
*/
#ifdef MEMORY_DEBUG
# error "The MEMORY_DEBUG macro is obsolete.  Use SQLITE_DEBUG instead."
#endif










#ifdef SQLITE_DEBUG
int sqlite3_os_trace = 0;
static int last_page = 0;
#define SEEK(X)           last_page=(X)
#define TRACE1(X)         if( sqlite3_os_trace ) sqlite3DebugPrintf(X)
#define TRACE2(X,Y)       if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y)
#define TRACE3(X,Y,Z)     if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z)

** If we compile with the SQLITE_TEST macro set, then the following block
** of code will give us the ability to simulate a disk I/O error.  This
** is used for testing the I/O recovery logic.
*/
#ifdef SQLITE_TEST
int sqlite3_io_error_pending = 0;
int sqlite3_diskfull_pending = 0;

#define SimulateIOError(A)  \
   if( sqlite3_io_error_pending ) \
     if( sqlite3_io_error_pending-- == 1 ){ local_ioerr(); return A; }
static void local_ioerr(){
  sqlite3_io_error_pending = 0;  /* Really just a place to set a breakpoint */
}
#define SimulateDiskfullError \
   if( sqlite3_diskfull_pending ) \
     if( sqlite3_diskfull_pending-- == 1 ){ local_ioerr(); return SQLITE_FULL; }







#else
#define SimulateIOError(A)
#define SimulateDiskfullError
#endif

/*
** When testing, keep a count of the number of open files.

*/
#include "sqliteInt.h"
#include "os.h"
#if OS_UNIX              /* This file is used on unix only */


#include <time.h>

#include <errno.h>
#include <unistd.h>

/*
** Do not include any of the File I/O interface procedures if the
** SQLITE_OMIT_DISKIO macro is defined (indicating that there database
** will be in-memory only)

/*
** Move the read/write pointer in a file.
*/
int sqlite3OsSeek(OsFile *id, i64 offset){
  assert( id->isOpen );
  SEEK(offset/1024 + 1);



  lseek(id->h, offset, SEEK_SET);
  return SQLITE_OK;
}

#ifdef SQLITE_TEST
/*
** Count the number of fullsyncs and normal syncs.  This is used to test

**
** The SQLITE_NO_SYNC macro disables all fsync()s.  This is useful
** for testing when we want to run through the test suite quickly.
** You are strongly advised *not* to deploy with SQLITE_NO_SYNC
** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash
** or power failure will likely corrupt the database file.
*/
static int full_fsync(int fd, int fullSync){
  int rc;

  /* Record the number of times that we do a normal fsync() and 
  ** FULLSYNC.  This is used during testing to verify that this procedure
  ** gets called with the correct arguments.
  */
#ifdef SQLITE_TEST

    rc = fcntl(fd, F_FULLFSYNC, 0);
  }else{
    rc = 1;
  }
  /* If the FULLSYNC failed, try to do a normal fsync() */
  if( rc ) rc = fsync(fd);





#else


  rc = fsync(fd);

#endif /* defined(F_FULLFSYNC) */
#endif /* defined(SQLITE_NO_SYNC) */

  return rc;
}

/*
** Make sure all writes to a particular file are committed to disk.




**
** Under Unix, also make sure that the directory entry for the file
** has been created by fsync-ing the directory that contains the file.
** If we do not do this and we encounter a power failure, the directory
** entry for the journal might not exist after we reboot.  The next
** SQLite to access the file will not know that the journal exists (because
** the directory entry for the journal was never created) and the transaction
** will not roll back - possibly leading to database corruption.
*/
int sqlite3OsSync(OsFile *id){
  assert( id->isOpen );
  SimulateIOError(SQLITE_IOERR);
  TRACE2("SYNC    %-3d\n", id->h);
  if( full_fsync(id->h, id->fullSync) ){
    return SQLITE_IOERR;
  }
  if( id->dirfd>=0 ){
    TRACE2("DIRSYNC %-3d\n", id->dirfd);
    full_fsync(id->dirfd, id->fullSync);
    close(id->dirfd);  /* Only need to sync once, so close the directory */
    id->dirfd = -1;    /* when we are done. */
  }
  return SQLITE_OK;
}

/*

** is no longer needed.
*/
char *sqlite3OsFullPathname(const char *zRelative){
  char *zFull = 0;
  if( zRelative[0]=='/' ){
    sqlite3SetString(&zFull, zRelative, (char*)0);
  }else{

    char zBuf[5000];


    zBuf[0] = 0;
    sqlite3SetString(&zFull, getcwd(zBuf, sizeof(zBuf)), "/", zRelative,
                    (char*)0);

  }
  return zFull;
}


#endif /* SQLITE_OMIT_DISKIO */
/***************************************************************************

/*
** Find the current time (in Universal Coordinated Time).  Write the
** current time and date as a Julian Day number into *prNow and
** return 0.  Return 1 if the time and date cannot be found.
*/
int sqlite3OsCurrentTime(double *prNow){

  time_t t;
  time(&t);
  *prNow = t/86400.0 + 2440587.5;






#ifdef SQLITE_TEST
  if( sqlite3_current_time ){
    *prNow = sqlite3_current_time/86400.0 + 2440587.5;
  }
#endif
  return 0;
}

#endif /* OS_UNIX */

/*
** Do not include any of the File I/O interface procedures if the
** SQLITE_OMIT_DISKIO macro is defined (indicating that there database
** will be in-memory only)
*/
#ifndef SQLITE_OMIT_DISKIO

/*


















































































** Delete the named file
*/
int sqlite3OsDelete(const char *zFilename){





  DeleteFileA(zFilename);

  TRACE2("DELETE \"%s\"\n", zFilename);
  return SQLITE_OK;
}

/*
** Return TRUE if the named file exists.
*/
int sqlite3OsFileExists(const char *zFilename){






  return GetFileAttributesA(zFilename) != 0xffffffff;


}

#ifndef _WIN32_WCE
/*
** Attempt to open a file for both reading and writing.  If that
** fails, try opening it read-only.  If the file does not exist,
** try to create it.

*/
int sqlite3OsOpenReadWrite(
  const char *zFilename,
  OsFile *id,
  int *pReadonly
){
  HANDLE h;

  assert( !id->isOpen );




























  h = CreateFileA(zFilename,
     GENERIC_READ | GENERIC_WRITE,
     FILE_SHARE_READ | FILE_SHARE_WRITE,
     NULL,
     OPEN_ALWAYS,
     FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
     NULL
  );
  if( h==INVALID_HANDLE_VALUE ){
    h = CreateFileA(zFilename,
       GENERIC_READ,
       FILE_SHARE_READ,
       NULL,
       OPEN_ALWAYS,
       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
       NULL
    );
    if( h==INVALID_HANDLE_VALUE ){
      return SQLITE_CANTOPEN;




    }
    *pReadonly = 1;
  }else{
    *pReadonly = 0;
  }
  id->h = h;
  id->locktype = NO_LOCK;
  id->sharedLockByte = 0;
  id->isOpen = 1;
  OpenCounter(+1);
  TRACE3("OPEN R/W %d \"%s\"\n", h, zFilename);

** On success, write the file handle into *id and return SQLITE_OK.
**
** On failure, return SQLITE_CANTOPEN.
*/
int sqlite3OsOpenExclusive(const char *zFilename, OsFile *id, int delFlag){
  HANDLE h;
  int fileflags;

  assert( !id->isOpen );
  if( delFlag ){
    fileflags = FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_RANDOM_ACCESS 
                     | FILE_FLAG_DELETE_ON_CLOSE;
  }else{
    fileflags = FILE_FLAG_RANDOM_ACCESS;
  }











  h = CreateFileA(zFilename,
     GENERIC_READ | GENERIC_WRITE,
     0,
     NULL,
     CREATE_ALWAYS,
     fileflags,
     NULL
  );

  if( h==INVALID_HANDLE_VALUE ){
    return SQLITE_CANTOPEN;
  }
  id->h = h;
  id->locktype = NO_LOCK;
  id->sharedLockByte = 0;
  id->isOpen = 1;

**
** On success, write the file handle into *id and return SQLITE_OK.
**
** On failure, return SQLITE_CANTOPEN.
*/
int sqlite3OsOpenReadOnly(const char *zFilename, OsFile *id){
  HANDLE h;

  assert( !id->isOpen );











  h = CreateFileA(zFilename,
     GENERIC_READ,
     0,
     NULL,
     OPEN_EXISTING,
     FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS,
     NULL
  );

  if( h==INVALID_HANDLE_VALUE ){
    return SQLITE_CANTOPEN;
  }
  id->h = h;
  id->locktype = NO_LOCK;
  id->sharedLockByte = 0;
  id->isOpen = 1;
  OpenCounter(+1);
  TRACE3("OPEN RO %d \"%s\"\n", h, zFilename);
  return SQLITE_OK;
}
#endif /* !defined(_WIN32_WCE) */

/*
** Attempt to open a file descriptor for the directory that contains a
** file.  This file descriptor can be used to fsync() the directory
** in order to make sure the creation of a new file is actually written
** to disk.
**

    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "0123456789";
  int i, j;
  char zTempPath[SQLITE_TEMPNAME_SIZE];
  if( sqlite3_temp_directory ){
    strncpy(zTempPath, sqlite3_temp_directory, SQLITE_TEMPNAME_SIZE-30);
    zTempPath[SQLITE_TEMPNAME_SIZE-30] = 0;










  }else{
    GetTempPathA(SQLITE_TEMPNAME_SIZE-30, zTempPath);
  }
  for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
  zTempPath[i] = 0;
  for(;;){
    sprintf(zBuf, "%s\\"TEMP_FILE_PREFIX, zTempPath);

    TRACE2("CLOSE %d\n", id->h);
    CloseHandle(id->h);
    OpenCounter(-1);
    id->isOpen = 0;
  }
  return SQLITE_OK;
}
#endif

/*
** Read data from a file into a buffer.  Return SQLITE_OK if all
** bytes were read successfully and SQLITE_IOERR if anything goes
** wrong.
*/
int sqlite3OsRead(OsFile *id, void *pBuf, int amt){

  }
  if( !rc || amt>(int)wrote ){
    return SQLITE_FULL;
  }
  return SQLITE_OK;
}








/*
** Move the read/write pointer in a file.
*/
int sqlite3OsSeek(OsFile *id, i64 offset){
  LONG upperBits = offset>>32;
  LONG lowerBits = offset & 0xffffffff;
  DWORD rc;
  assert( id->isOpen );



  SEEK(offset/1024 + 1);
  rc = SetFilePointer(id->h, lowerBits, &upperBits, FILE_BEGIN);
  TRACE3("SEEK %d %lld\n", id->h, offset);



  return SQLITE_OK;
}

/*
** Make sure all writes to a particular file are committed to disk.
*/
int sqlite3OsSync(OsFile *id){
  assert( id->isOpen );
  TRACE3("SYNC %d lock=%d\n", id->h, id->locktype);
  if( FlushFileBuffers(id->h) ){
    return SQLITE_OK;
  }else{
    return SQLITE_IOERR;
  }

  SimulateIOError(SQLITE_IOERR);
  lowerBits = GetFileSize(id->h, &upperBits);
  *pSize = (((i64)upperBits)<<32) + lowerBits;
  return SQLITE_OK;
}

#ifndef _WIN32_WCE
/*
** Return true (non-zero) if we are running under WinNT, Win2K or WinXP.
** Return false (zero) for Win95, Win98, or WinME.
**
** Here is an interesting observation:  Win95, Win98, and WinME lack
** the LockFileEx() API.  But we can still statically link against that
** API as long as we don't call it win running Win95/98/ME.  A call to
** this routine is used to determine if the host is Win95/98/ME or
** WinNT/2K/XP so that we will know whether or not we can safely call
** the LockFileEx() API.
*/
static int isNT(void){
  static int osType = 0;   /* 0=unknown 1=win95 2=winNT */
  if( osType==0 ){
    OSVERSIONINFO sInfo;
    sInfo.dwOSVersionInfoSize = sizeof(sInfo);
    GetVersionEx(&sInfo);
    osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
  }
  return osType==2;
}

/*
** Acquire a reader lock.
** Different API routines are called depending on whether or not this
** is Win95 or WinNT.
*/
static int getReadLock(OsFile *id){
  int res;

}

#ifndef SQLITE_OMIT_PAGER_PRAGMAS
/*
** Check that a given pathname is a directory and is writable 
**
*/
int sqlite3OsIsDirWritable(char *zBuf){
  int fileAttr;

  if(! zBuf ) return 0;
  if(! isNT() && strlen(zBuf) > MAX_PATH ) return 0;


  fileAttr = GetFileAttributesA(zBuf);




  if( fileAttr == 0xffffffff ) return 0;
  if( (fileAttr & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY ){
    return 0;
  }
  return 1;
}
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */

  }
  if( type>=PENDING_LOCK ){
    UnlockFile(id->h, PENDING_BYTE, 0, 1, 0);
  }
  id->locktype = locktype;
  return rc;
}

#endif /* !defined(_WIN32_WCE) */

/*
** Turn a relative pathname into a full pathname.  Return a pointer
** to the full pathname stored in space obtained from sqliteMalloc().
** The calling function is responsible for freeing this space once it
** is no longer needed.
*/
char *sqlite3OsFullPathname(const char *zRelative){
  char *zNotUsed;
  char *zFull;

  int nByte;
#ifdef __CYGWIN__
  nByte = strlen(zRelative) + MAX_PATH + 1001;
  zFull = sqliteMalloc( nByte );
  if( zFull==0 ) return 0;
  if( cygwin_conv_to_full_win32_path(zRelative, zFull) ) return 0;
#else











  nByte = GetFullPathNameA(zRelative, 0, 0, &zNotUsed) + 1;
  zFull = (char *)sqliteMalloc( nByte );
  if( zFull==0 ) return 0;
  GetFullPathNameA(zRelative, nByte, zFull, &zNotUsed);

#endif
  return zFull;
}

#endif /* SQLITE_OMIT_DISKIO */
/***************************************************************************
** Everything above deals with file I/O.  Everything that follows deals

#endif //_WIN32_WCE
};


#define SQLITE_TEMPNAME_SIZE (MAX_PATH+50)
#define SQLITE_MIN_SLEEP_MS 1


/*
** This are WIN32 API functions not present in WinCE.
** They are implemented in the "os_wince.c" file.
**/
#ifdef _WIN32_WCE
# define DeleteFileA				sqlitewce_DeleteFileA
# define GetFileAttributesA			sqlitewce_GetFileAttributesA

** To avoid any problems I just use my own implementation.
** It should be safe, as this header is not included by normal
** programs, only by the SQLite library.
**/
#if _WIN32_WCE >= 400
# define localtime					sqlitewce_localtime
#endif


#endif /* _SQLITE_OS_WIN_H_ */

** This is needed for the command line version of sqlite to compile.
**/
int isatty( int handle )
{
	UNREFERENCED_PARAMETER(handle);
	return 1;
}







/*
** Converts a relative path to an absolute path.
** There is no current directory concept on Windows CE, so we assume
** we are working always with absolute paths and simply copy
** the given path to the provided buffer.
*/

** NOTE: I'm not sure in what conditions this can turn into an infinite
**       loop. I don't think it is possible without a serious bug in
**       sqlite or windows, but i'm not sure of this.
*/
static void lock_file( OsFile *id )
{
	DWORD res;


	while ( 1 )
	{
		res = WaitForSingleObject( id->hMux, INFINITE );
		// I don't know very well what I have to do in this case.
		// The MSDN says that this case is when a thread terminates without
		// releasing the mutex. So I have to release it and try again
		if ( res == WAIT_ABANDONED )

/*
** Releases ownership of the file mutex.
** Always success
*/
static void unlock_file( OsFile *id )
{

	ReleaseMutex( id->hMux );
}

/*
** Acquire a lock on the file.
** Returns non-zero on success, zero on failure.
*/
static int getLock( OsFile *id, int locktype )
{
	int rc = 0;


	lock_file( id );

	if ( locktype == SHARED_LOCK )
	{
		assert( id->lockdata->shared >= 0 );
		++id->lockdata->shared;	/* Increment number of readers */
		id->lockdata->lock |= 1 << SHARED_LOCK;
	}
	else

/*
** Releases lock on the file.
** Always succeeds, so no return value.
*/
static void unsetLock( OsFile *id, int locktype )
{
	assert( locktype >= SHARED_LOCK );


	lock_file( id );
	if ( locktype == SHARED_LOCK )
	{
		assert( id->lockdata->shared > 0 );
		--id->lockdata->shared;	/* Decrement number of readers */
		if ( id->lockdata->shared == 0 )	/* Last reader? */
			id->lockdata->lock &= ~(1 << SHARED_LOCK);
	}

	id->h = h;
	id->locktype = NO_LOCK;
	id->sharedLockByte = 0;
	id->isOpen = 1;
	id->wFilename = wFilename;
	id->delOnClose = delFlag;
#ifndef SQLITE_WCE_OMIT_FILELOCK
	// Not shared, so no need to lock file (it would fail to open)
	id->hMux = NULL;
	id->hMem = NULL;
	id->lockdata = NULL;
#endif
	OpenCounter(+1);
	TRACE3("OPEN EX %d \"%s\"\n", h, zFilename);
	return SQLITE_OK;
}

/*

	id->h = h;
	id->locktype = NO_LOCK;
	id->sharedLockByte = 0;
	id->isOpen = 1;
	id->wFilename = wFilename;
	id->delOnClose = 0;
#ifndef SQLITE_WCE_OMIT_FILELOCK
	// Not shared, so no need to lock file
	id->hMux = NULL;
	id->hMem = NULL;
	id->lockdata = NULL;
#endif
	OpenCounter(+1);
	TRACE3("OPEN RO %d \"%s\"\n", h, zFilename);
	return SQLITE_OK;
}

/*

** 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.9 2005/09/01 06:07:55 rmsimpson Exp $
*/
#ifndef SQLITE_OMIT_DISKIO
#include "sqliteInt.h"
#include "os.h"
#include "pager.h"
#include <assert.h>
#include <string.h>

    rc = write32bits(&pPager->jfd, pPager->sectorSize);
  }

  /* The journal header has been written successfully. Seek the journal
  ** file descriptor to the end of the journal header sector.
  */
  if( rc==SQLITE_OK ){
    sqlite3OsSeek(&pPager->jfd, pPager->journalOff-1);

    rc = sqlite3OsWrite(&pPager->jfd, "\000", 1);

  }
  return rc;
}

/*
** The journal file must be open when this is called. A journal header file
** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal

  ** page content is in the main journal either because the page is not in
  ** cache or else it is marked as needSync==0.
  */
  pPg = pager_lookup(pPager, pgno);
  assert( pPager->state>=PAGER_EXCLUSIVE || pPg!=0 );
  TRACE3("PLAYBACK %d page %d\n", PAGERID(pPager), pgno);
  if( pPager->state>=PAGER_EXCLUSIVE && (pPg==0 || pPg->needSync==0) ){
    sqlite3OsSeek(&pPager->fd, (pgno-1)*(i64)pPager->pageSize);

    rc = sqlite3OsWrite(&pPager->fd, aData, pPager->pageSize);

    if( pPg ) pPg->dirty = 0;
  }
  if( pPg ){
    /* No page should ever be explicitly rolled back that is in use, except
    ** for page 1 which is held in use in order to keep the lock on the
    ** database active. However such a page may be rolled back as a result
    ** of an internal error resulting in an automatic call to

static int pager_reload_cache(Pager *pPager){
  PgHdr *pPg;
  int rc = SQLITE_OK;
  for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){
    char zBuf[SQLITE_MAX_PAGE_SIZE];
    if( !pPg->dirty ) continue;
    if( (int)pPg->pgno <= pPager->origDbSize ){
      sqlite3OsSeek(&pPager->fd, pPager->pageSize*(i64)(pPg->pgno-1));

      rc = sqlite3OsRead(&pPager->fd, zBuf, pPager->pageSize);

      TRACE3("REFETCH %d page %d\n", PAGERID(pPager), pPg->pgno);
      if( rc ) break;
      CODEC(pPager, zBuf, pPg->pgno, 2);
    }else{
      memset(zBuf, 0, pPager->pageSize);
    }
    if( pPg->nRef==0 || memcmp(zBuf, PGHDR_TO_DATA(pPg), pPager->pageSize) ){

  }

  pPager->journalOff = szJ;
  
end_stmt_playback:
  if( rc!=SQLITE_OK ){
    pPager->errMask |= PAGER_ERR_CORRUPT;
    rc = SQLITE_CORRUPT;  /* bkpt-CORRUPT */
  }else{
    pPager->journalOff = szJ;
    /* pager_reload_cache(pPager); */
  }
  return rc;
}

    sqlite3OsSeek(&pPager->fd, 0);
    sqlite3OsRead(&pPager->fd, pDest, N);
  }
}

/*
** Return the total number of pages in the disk file associated with
** pPager.





*/
int sqlite3pager_pagecount(Pager *pPager){
  i64 n;
  assert( pPager!=0 );
  if( pPager->dbSize>=0 ){
    return pPager->dbSize;
  }
  if( sqlite3OsFileSize(&pPager->fd, &n)!=SQLITE_OK ){
    pPager->errMask |= PAGER_ERR_DISK;
    return 0;
  }
  if( n>0 && n<pPager->pageSize ){
    n = 1;
  }else{
    n /= pPager->pageSize;
  }
  if( !MEMDB && n==PENDING_BYTE/pPager->pageSize ){
    n++;
  }
  if( pPager->state!=PAGER_UNLOCK ){
    pPager->dbSize = n;




  }
  return n;
}

/*
** Forward declaration
*/

        /* Write the nRec value into the journal file header. If in
        ** full-synchronous mode, sync the journal first. This ensures that
        ** all data has really hit the disk before nRec is updated to mark
        ** it as a candidate for rollback. 
        */
        if( pPager->fullSync ){
          TRACE2("SYNC journal of %d\n", PAGERID(pPager));
          rc = sqlite3OsSync(&pPager->jfd);
          if( rc!=0 ) return rc;
        }

        sqlite3OsSeek(&pPager->jfd, pPager->journalHdr + sizeof(aJournalMagic));

        rc = write32bits(&pPager->jfd, pPager->nRec);
        if( rc ) return rc;

        sqlite3OsSeek(&pPager->jfd, pPager->journalOff);

      }
      TRACE2("SYNC journal of %d\n", PAGERID(pPager));
      rc = sqlite3OsSync(&pPager->jfd);
      if( rc!=0 ) return rc;
      pPager->journalStarted = 1;
    }
    pPager->needSync = 0;

    /* Erase the needSync flag from every page.
    */

  rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
  if( rc!=SQLITE_OK ){
    return rc;
  }

  while( pList ){
    assert( pList->dirty );
    sqlite3OsSeek(&pPager->fd, (pList->pgno-1)*(i64)pPager->pageSize);

    /* If there are dirty pages in the page cache with page numbers greater
    ** than Pager.dbSize, this means sqlite3pager_truncate() was called to
    ** make the file smaller (presumably by auto-vacuum code). Do not write
    ** any such pages to the file.
    */
    if( pList->pgno<=pPager->dbSize ){
      CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6);

int sqlite3pager_get(Pager *pPager, Pgno pgno, void **ppPage){
  PgHdr *pPg;
  int rc;

  /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page
  ** number greater than this, or zero, is requested.
  */
  if( pgno>PAGER_MAX_PGNO || pgno==0 ){
    return SQLITE_CORRUPT;
  }

  /* Make sure we have not hit any critical errors.
  */ 
  assert( pPager!=0 );
  *ppPage = 0;
  if( pPager->errMask & ~(PAGER_ERR_FULL) ){

      return rc;
    }
    if( sqlite3pager_pagecount(pPager)<(int)pgno ){
      memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize);
    }else{
      int rc;
      assert( MEMDB==0 );
      sqlite3OsSeek(&pPager->fd, (pgno-1)*(i64)pPager->pageSize);

      rc = sqlite3OsRead(&pPager->fd, PGHDR_TO_DATA(pPg), pPager->pageSize);

      TRACE3("FETCH %d page %d\n", PAGERID(pPager), pPg->pgno);
      CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3);
      if( rc!=SQLITE_OK ){
        i64 fileSize;
        if( sqlite3OsFileSize(&pPager->fd,&fileSize)!=SQLITE_OK
               || fileSize>=pgno*pPager->pageSize ){
          sqlite3pager_unref(PGHDR_TO_DATA(pPg));

          assert( pHist->pOrig==0 );
          pHist->pOrig = sqliteMallocRaw( pPager->pageSize );
          if( pHist->pOrig ){
            memcpy(pHist->pOrig, PGHDR_TO_DATA(pPg), pPager->pageSize);
          }
        }else{
          u32 cksum;




          CODEC(pPager, pData, pPg->pgno, 7);
          cksum = pager_cksum(pPager, pPg->pgno, pData);
          saved = *(u32*)PGHDR_TO_EXTRA(pPg, pPager);
          store32bits(cksum, pPg, pPager->pageSize);
          szPg = pPager->pageSize+8;
          store32bits(pPg->pgno, pPg, -4);
          rc = sqlite3OsWrite(&pPager->jfd, &((char*)pData)[-4], szPg);

    if( rc==SQLITE_OK ){
      rc = rc2;
    }
  }else{
    rc = pager_playback(pPager);
  }
  if( rc!=SQLITE_OK ){
    rc = SQLITE_CORRUPT;  /* bkpt-CORRUPT */
    pPager->errMask |= PAGER_ERR_CORRUPT;
  }
  pPager->dbSize = -1;
  return rc;
}

/*

      if( nTrunc!=0 ){
        /* If this transaction has made the database smaller, then all pages
        ** being discarded by the truncation must be written to the journal
        ** file.
        */
        Pgno i;
        void *pPage;

        for( i=nTrunc+1; i<=pPager->origDbSize; i++ ){
          if( !(pPager->aInJournal[i/8] & (1<<(i&7))) ){
            rc = sqlite3pager_get(pPager, i, &pPage);
            if( rc!=SQLITE_OK ) goto sync_exit;
            rc = sqlite3pager_write(pPage);
            sqlite3pager_unref(pPage);
            if( rc!=SQLITE_OK ) goto sync_exit;
          }
        } 

    /* Write all dirty pages to the database file */
    pPg = pager_get_all_dirty_pages(pPager);
    rc = pager_write_pagelist(pPg);
    if( rc!=SQLITE_OK ) goto sync_exit;

    /* Sync the database file. */
    if( !pPager->noSync ){
      rc = sqlite3OsSync(&pPager->fd);
    }

    pPager->state = PAGER_SYNCED;
  }

sync_exit:
  return rc;

**    May you share freely, never taking more than you give.
**
*************************************************************************
** This header file defines the interface that the sqlite page cache
** subsystem.  The page cache subsystem reads and writes a file a page
** at a time and provides a journal for rollback.
**
** @(#) $Id: pager.h,v 1.9 2005/09/01 06:07:56 rmsimpson Exp $
*/

/*
** The default size of a database page.
*/
#ifndef SQLITE_DEFAULT_PAGE_SIZE
# define SQLITE_DEFAULT_PAGE_SIZE 1024
#endif

/* Maximum page size.  The upper bound on this value is 32768.  This a limit
** imposed by necessity of storing the value in a 2-byte unsigned integer
** and the fact that the page size must be a power of 2.
**
** This value is used to initialize certain arrays on the stack at
** various places in the code.  On embedded machines where stack space
** is limited and the flexibility of having large pages is not needed,
** it makes good sense to reduce the maximum page size to something more
** reasonable, like 1024.
*/
#ifndef SQLITE_MAX_PAGE_SIZE
# define SQLITE_MAX_PAGE_SIZE 8192
#endif

/*
** Maximum number of pages in one database.
*/
#define SQLITE_MAX_PAGE 1073741823

**    sqlite3ParserARG_FETCH     Code to extract %extra_argument from yypParser
**    YYNSTATE           the combined number of states.
**    YYNRULE            the number of rules in the grammar
**    YYERRORSYMBOL      is the code number of the error symbol.  If not
**                       defined, then do no error processing.
*/
#define YYCODETYPE unsigned char
#define YYNOCODE 244
#define YYACTIONTYPE unsigned short int
#define sqlite3ParserTOKENTYPE Token
typedef union {
  sqlite3ParserTOKENTYPE yy0;
  struct {int value; int mask;} yy35;
  Expr* yy44;
  int yy58;
  Select* yy99;
  struct LimitVal yy112;
  Token yy144;
  TriggerStep* yy203;
  struct TrigEvent yy234;
  IdList* yy258;



  struct AttachKey yy300;
  SrcList* yy367;
  ExprList* yy412;
  struct LikeOp yy432;
  int yy487;
} YYMINORTYPE;
#define YYSTACKDEPTH 100
#define sqlite3ParserARG_SDECL Parse *pParse;
#define sqlite3ParserARG_PDECL ,Parse *pParse
#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
#define sqlite3ParserARG_STORE yypParser->pParse = pParse
#define YYNSTATE 578
#define YYNRULE 310
#define YYERRORSYMBOL 143
#define YYERRSYMDT yy487
#define YYFALLBACK 1
#define YY_NO_ACTION      (YYNSTATE+YYNRULE+2)
#define YY_ACCEPT_ACTION  (YYNSTATE+YYNRULE+1)
#define YY_ERROR_ACTION   (YYNSTATE+YYNRULE)

/* Next are that tables used to determine what action to take based on the
** current state and lookahead token.  These tables are used to implement

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







 /*   110 */    70,   71,   72,   73,   74,   75,   76,   77,  191,   79,
 /*   120 */    80,   81,   82,   83,   84,   85,   86,   87,   88,  192,
 /*   130 */    25,  152,   62,  192,  168,  169,  170,   10,   27,  160,
 /*   140 */   161,  204,  205,   92,   93,   94,  209,  117,   97,   98,
 /*   150 */    99,   46,   94,   83,   84,   97,   98,   99,  217,   47,
 /*   160 */   109,  102,   92,  184,  185,   25,   96,  109,  241,   64,
 /*   170 */    65,   66,   67,   68,   69,   70,   71,   72,   73,   74,
 /*   180 */    75,   76,   77,  150,   79,   80,   81,   82,   83,   84,
 /*   190 */    85,   86,   87,   88,   83,   84,  230,  152,   46,  129,
 /*   200 */   130,  131,  157,   92,   93,  160,  161,   18,  144,  145,
 /*   210 */   146,   10,   11,  149,  103,  103,   64,   65,   66,   67,

 /*   220 */    68,   69,   70,   71,   72,   73,   74,   75,   76,   77,
 /*   230 */   152,   79,   80,   81,   82,   83,   84,   85,   86,   87,
 /*   240 */    88,  146,   53,   94,  149,   46,   97,   98,   99,   14,
 /*   250 */    15,   16,  165,   85,   86,   87,   88,  117,  109,  220,
 /*   260 */   221,  222,  223,   64,   65,   66,   67,   68,   69,   70,


 /*   270 */    71,   72,   73,   74,   75,   76,   77,  152,   79,   80,
 /*   280 */    81,   82,   83,   84,   85,   86,   87,   88,  136,  211,
 /*   290 */   203,   18,   66,  104,  105,  106,   10,  152,  173,  174,
 /*   300 */    23,   62,   25,   24,  115,   26,  151,  220,  152,  222,
 /*   310 */   223,  152,   23,   27,  169,  170,   27,  175,  159,   46,
 /*   320 */    94,   95,   96,   97,   98,   99,  100,  101,   10,  173,
 /*   330 */   174,   92,  173,  174,  108,   96,  137,   64,   65,   66,
 /*   340 */    67,   68,   69,   70,   71,   72,   73,   74,   75,   76,
 /*   350 */    77,  192,   79,   80,   81,   82,   83,   84,   85,   86,
 /*   360 */    87,   88,  220,   23,  222,  223,   46,   27,  129,  130,
 /*   370 */   131,  215,   93,  180,  181,  230,  152,  159,   92,   93,
 /*   380 */   187,   92,   93,  227,   64,   65,   66,   67,   68,   69,
 /*   390 */    70,   71,   72,   73,   74,   75,   76,   77,  119,   79,
 /*   400 */    80,   81,   82,   83,   84,   85,   86,   87,   88,  152,
 /*   410 */   192,   66,   24,  152,   19,  171,  172,   24,   24,  165,
 /*   420 */   166,  167,  112,   28,  180,   24,  116,   27,  152,   27,
 /*   430 */   173,  174,   92,  152,   18,  217,   41,   10,   43,  159,
 /*   440 */    46,   96,   97,   98,   99,  100,  101,  152,   53,  173,
 /*   450 */   174,  233,  191,  108,  173,  174,  238,  137,   64,   65,
 /*   460 */    66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
 /*   470 */    76,   77,  192,   79,   80,   81,   82,   83,   84,   85,
 /*   480 */    86,   87,   88,   24,  227,   27,   10,   46,  212,  213,

 /*   490 */    27,   24,   92,   93,   92,  152,  215,  217,  152,  111,
 /*   500 */   152,  113,  114,   27,  111,   46,  113,  114,  227,   68,
 /*   510 */    69,  216,  111,  233,  113,  114,  173,  174,  238,  173,
 /*   520 */   174,  173,  174,   64,   65,   66,   67,   68,   69,   70,
 /*   530 */    71,   72,   73,   74,   75,   76,   77,   96,   79,   80,
 /*   540 */    81,   82,   83,   84,   85,   86,   87,   88,   24,   19,



 /*   550 */    92,   93,  136,   31,  138,   92,   93,   23,   28,  213,
 /*   560 */    38,   27,   10,   27,   47,  152,   10,  224,   92,   93,
 /*   570 */    46,   41,   10,   43,   14,   15,   10,  119,  111,  151,
 /*   580 */   113,  114,  119,   66,  154,  152,  173,  174,   64,   65,
 /*   590 */    66,   67,   68,   69,   70,   71,   72,   73,   74,   75,
 /*   600 */    76,   77,  152,   79,   80,   81,   82,   83,   84,   85,
 /*   610 */    86,   87,   88,   10,   10,  195,   13,   46,   10,  186,
 /*   620 */   103,   85,  202,  173,  174,  108,   92,   93,   92,   93,
 /*   630 */    12,  220,  219,  222,  223,   64,   65,   66,   67,   68,
 /*   640 */    69,   70,   71,   72,   73,   74,   75,   76,   77,   10,
 /*   650 */    79,   80,   81,   82,   83,   84,   85,   86,   87,   88,

 /*   660 */   151,   26,  229,  111,   46,  113,  114,  111,  152,  113,
 /*   670 */   114,  165,   21,  111,  103,  113,  114,  111,  152,  113,
 /*   680 */   114,   10,   64,   65,   66,   67,   68,   69,   70,   71,
 /*   690 */    72,   73,   74,   75,   76,   77,   34,   79,   80,   81,
 /*   700 */    82,   83,   84,   85,   86,   87,   88,   10,   57,  203,
 /*   710 */    59,   46,  186,   83,   84,  111,   54,  113,  114,  111,
 /*   720 */    23,  113,  114,  104,  105,  106,  152,  211,   93,   64,
 /*   730 */    65,   66,   67,   68,   69,   70,   71,   72,   73,   74,
 /*   740 */    75,   76,   77,  152,   79,   80,   81,   82,   83,   84,
 /*   750 */    85,   86,   87,   88,  119,  229,   27,  164,   46,  152,
 /*   760 */   186,  104,  105,  106,  173,  174,  173,  160,  161,  107,
 /*   770 */    73,   10,   24,  152,   26,   21,   64,   65,   66,   67,
 /*   780 */    68,   69,   70,   71,   72,   73,   74,   75,   76,   77,
 /*   790 */   139,   79,   80,   81,   82,   83,   84,   85,   86,   87,
 /*   800 */    88,  152,   10,  229,   25,   46,   27,  186,  129,  130,
 /*   810 */   219,   57,  112,   59,   24,  115,   26,   24,   26,   26,
 /*   820 */   152,   92,  173,  174,   65,   66,   67,   68,   69,   70,
 /*   830 */    71,   72,   73,   74,   75,   76,   77,  152,   79,   80,
 /*   840 */    81,   82,   83,   84,   85,   86,   87,   88,  152,   10,
 /*   850 */   229,   10,   46,   24,  186,   26,  204,  205,  173,  174,
 /*   860 */   131,   24,   12,   26,  103,   22,   27,  152,   27,  173,

 /*   870 */   174,   92,   66,   67,   68,   69,   70,   71,   72,   73,
 /*   880 */    74,   75,   76,   77,  152,   79,   80,   81,   82,   83,
 /*   890 */    84,   85,   86,   87,   88,  152,   23,  229,   29,  152,
 /*   900 */    27,  152,   33,   96,  159,  173,  174,   23,   35,  151,
 /*   910 */   155,   27,   66,   10,   45,  108,  173,  174,  126,   35,
 /*   920 */   173,  174,  173,  174,   49,   52,  152,   95,   96,  158,
 /*   930 */   152,   92,   93,   92,   93,   62,   52,  192,  152,   66,
 /*   940 */   152,   98,   96,   24,  229,   26,   62,  173,  174,  152,
 /*   950 */    66,  173,  174,   24,  165,   26,   83,   84,   85,  173,
 /*   960 */   174,  173,  174,  159,   91,   92,   93,   83,   84,   96,
 /*   970 */   173,  174,   24,  152,   26,   91,   92,   93,  103,  152,
 /*   980 */    96,   23,  139,  228,   10,   27,  136,  232,   26,  159,
 /*   990 */   152,   10,  203,   35,  173,  174,  192,   55,   56,  115,
 /*  1000 */   173,  174,  129,  130,  131,  132,  133,  134,  135,  103,
 /*  1010 */    52,  173,  174,  129,  130,  131,  132,  133,  134,  135,
 /*  1020 */    62,   24,  192,  117,   66,   24,  152,   26,  163,  189,
 /*  1030 */   190,   24,   64,   26,  152,   10,   24,  152,   26,  152,
 /*  1040 */    23,   83,   84,   10,   27,  152,   10,  173,  174,   91,
 /*  1050 */    92,   93,   35,  152,   96,  173,  174,  152,  173,  174,
 /*  1060 */   173,  174,  152,  159,  152,  103,  173,  174,   23,   52,
 /*  1070 */   175,  159,   27,   48,  173,  174,  152,   36,  152,   62,
 /*  1080 */    35,  159,   61,   66,  152,  173,  174,  129,  130,  131,
 /*  1090 */   132,  133,  134,  135,  136,  127,  192,   52,  117,  115,
 /*  1100 */    83,   84,   85,  152,  192,  173,  174,   62,   91,   92,
 /*  1110 */    93,   66,  128,   96,  192,   12,  211,  191,  152,  152,
 /*  1120 */    17,   18,   19,   20,  173,  174,  103,  215,   83,   84,
 /*  1130 */   152,  115,  152,   30,  152,   32,   91,   92,   93,  227,
 /*  1140 */   216,   96,   39,  152,  128,  152,  129,  130,  131,  132,
 /*  1150 */   133,  134,  135,   24,   51,   26,   53,  191,  191,  126,
 /*  1160 */   152,   58,  141,   60,  173,  174,   63,  152,   44,  191,
 /*  1170 */   152,  191,  152,  191,  129,  130,  131,  132,  133,  134,
 /*  1180 */   135,  173,  174,  183,  191,  175,   48,  176,  173,  174,
 /*  1190 */   152,  173,  174,  173,  174,  152,  102,  175,  152,   23,
 /*  1200 */   152,  177,  152,  175,  152,  117,  152,  104,  105,  106,
 /*  1210 */   196,  173,  174,  110,  152,  117,  173,  174,  115,  173,
 /*  1220 */   174,  173,  174,  173,  174,  173,  174,  173,  174,  115,
 /*  1230 */   193,  192,  152,  126,  194,  173,  174,  152,  123,  152,
 /*  1240 */   198,  152,  124,  152,  197,  152,  121,  152,  199,  117,
 /*  1250 */   117,  200,  125,  173,  174,   23,  201,  152,  173,  174,
 /*  1260 */   173,  174,  173,  174,  173,  174,  173,  174,  173,  174,
 /*  1270 */    24,  152,   24,  165,   88,  231,   96,  115,  152,  115,
 /*  1280 */   115,   23,  136,  225,  231,  226,   18,   23,   26,  190,
 /*  1290 */    24,  152,  117,   24,  152,  122,  156,   26,  101,  176,
 /*  1300 */   214,   27,   26,  122,  214,  164,  176,  206,  152,  152,
 /*  1310 */   119,  152,  152,  103,  156,  120,  207,   23,  208,  152,
 /*  1320 */    24,  208,  117,  207,   24,  175,  152,   23,  179,  178,
 /*  1330 */   152,  214,  164,  181,  214,  182,  182,  182,   48,  176,
 /*  1340 */   152,   23,  176,  173,  183,  173,   24,   23,   23,   48,
 /*  1350 */   100,  152,  175,  108,  185,  152,  185,  178,  175,  177,
 /*  1360 */   156,  152,  156,  179,   25,  152,  235,  156,  234,   42,
 /*  1370 */   103,  156,  236,   12,  237,   40,  103,   49,  103,  139,
 /*  1380 */   152,  156,  103,  152,   10,   23,  139,  175,   12,  188,
 /*  1390 */   127,   18,  127,   10,   10,   18,   64,  197,  107,   73,
 /*  1400 */    10,  152,  188,  152,   73,  127,  152,  218,   23,   23,
 /*  1410 */    10,  118,  152,  197,   10,   10,   10,   10,   10,  197,
 /*  1420 */   118,   10,  188,  107,  197,   10,  127,   10,   10,  152,
 /*  1430 */    10,   10,   23,  152,   10,  218,  156,   10,  152,   10,
 /*  1440 */    24,  239,   10,   10,   25,   10,  239,   37,  165,  152,
 /*  1450 */   165,   10,   10,   10,  156,  152,   10,  152,  240,  152,
 /*  1460 */    21,  140,  156,  152,  141,  242,   10,  243,  243,  243,
 /*  1470 */   243,  142,
};
#define YY_SHIFT_USE_DFLT (-72)
static const short yy_shift_ofst[] = {
 /*     0 */   201,   81,  -72,  -72, 1103,   -9,  127,  -72,  235,  603,
 /*    10 */   318,  286,  427,  -72,  -72,  -72,  -72,  -72,  -72,  603,
 /*    20 */   639,  603,  671,  603,  903,  277,  974,  400,  748,  997,
 /*    30 */  1036,   51,  -72,  402,  -72,  226,  -72,  400,  345,  -72,
 /*    40 */  1023,  -72, 1041,  395,  -72,  -72,  -72,  -72,  -72,  -72,
 /*    50 */   -72,  807, 1023,  -72, 1124,  -72,  560,  -72,  -72, 1138,
 /*    60 */   522, 1023, 1094,  -72,  -72,  -72,  -72, 1023,  -72, 1176,
 /*    70 */  1045,   30,  873, 1088, 1098,  -72,  884,  -72,  388, 1114,
 /*    80 */   -72,  310,  -72,  -19, 1107, 1115, 1118, 1125, 1127,  -72,
 /*    90 */  1045,   40, 1045,  665, 1045,  -72, 1132,  400, 1133,  400,
 /*   100 */   -72,  -72,  -72,  -72,  -72,  -72, 1232, 1045,  105,  402,
 /*   110 */   -72,  -72,  340,  630,  790,  -72,  630, 1246,  -72,  -72,
 /*   120 */   -72,  679,  -72,  -72,  -72,  679,  -72,  -72,  -72,  -72,
 /*   130 */  1248,  -72, 1045,  -72,  759, 1045,  -11, 1045,  -11, 1045,
 /*   140 */   -11, 1045,  -11, 1045,  -71, 1045,  -71, 1045,  -50, 1045,
 /*   150 */   -50, 1045,  -50, 1045,  -50, 1045,  168, 1045,  168, 1045,
 /*   160 */  1186, 1045, 1186, 1045, 1186, 1045,  -72,  -72,  441,  -72,
 /*   170 */   -72,  -72,  -72, 1045,  -56, 1045,  -11,  -72,  846,  -72,
 /*   180 */  1180,  -72,  -72,  -72, 1045,  712, 1045,  -71,  -72,  289,
 /*   190 */   884,  393,  700, 1162, 1164, 1165,  -72,  665, 1045,  806,
 /*   200 */  1045,  -72, 1045,  -72, 1045,  -72, 1258, 1114,  401,  -72,
 /*   210 */   958,  152, 1146,  416, 1268,  -72, 1045,  199, 1045,  665,
 /*   220 */  1264,  530, 1266,  -72, 1262,  400, 1269,  -72, 1045,  273,
 /*   230 */  1045,  320, 1045,  665,  793,  -72, 1045,  -72,  -72, 1175,
 /*   240 */   400,  -72,  -72,  -72,  806, 1045,  665, 1173, 1045, 1271,
 /*   250 */  1045, 1197,  522,  -72, 1274,  -72,  -72,  665, 1197,  522,
 /*   260 */   -72, 1045,  665, 1181, 1045, 1276, 1045,  665,  -72,  -72,
 /*   270 */   635,  -72,  -72,  -72,  458,  -72,  463,  -72, 1191,  -72,
 /*   280 */   534, 1175,  779,  400,  -72,  -72, 1210, 1195,  -72, 1294,
 /*   290 */   400,  829,  -72,  400,  -72,  -72, 1045,  665, 1114,  467,
 /*   300 */   279, 1296,  779, 1210, 1195,  -72, 1017,  -25,  -72,  -72,
 /*   310 */  1205,  536,  -72,  -72,  -72,  -72,  394,  -72,  837,  -72,
 /*   320 */  1300,  -72,  459, 1023,  -72,  400, 1304,  -72,  112,  -72,
 /*   330 */   400,  -72,  619,  662,  -72,  832,  -72,  -72,  -72,  -72,
 /*   340 */   662,  -72,  662,  -72,  400,  919,  -72,  400, 1197,  522,
 /*   350 */   -72,  -72, 1197,  522,  -72,  -72, 1274,  -72, 1124,  -72,
 /*   360 */   -72,   70,  -72, 1045,  524,  -72,  239,  -72,  -72,  239,
 /*   370 */   -72,  -72,  -72,  -72,   58,  149,  -72,  400,  -72, 1290,
 /*   380 */  1318,  400,   59, 1322, 1023,  -72, 1324,  400,  929, 1023,
 /*   390 */   -72, 1045,  571,  -72, 1301, 1325,  400,  948, 1250,  400,
 /*   400 */  1304,  -72,  517, 1245,  -72,  -72,  -72,  -72,  -72, 1114,
 /*   410 */   552,  843,  754,  400, 1175,  -72,  400,  140, 1339, 1114,
 /*   420 */   556,  400, 1175,  869,  657, 1267,  400, 1175,  -72, 1327,
 /*   430 */   850, 1361, 1045,  618, 1335,  942,  -72,  -72, 1273, 1275,
 /*   440 */   875,  400,  962,  -72,  -72, 1328,  -72,  -72, 1240,  400,
 /*   450 */   906, 1279,  400, 1362,  400, 1001,  761, 1374, 1247, 1376,
 /*   460 */   189,  562,  968,  395,  -72, 1263, 1265, 1373, 1383, 1384,
 /*   470 */   189, 1377, 1332,  400, 1291,  400,  792,  400, 1326, 1045,
 /*   480 */   665, 1390, 1331, 1045,  665, 1278,  400, 1385,  400, 1007,
 /*   490 */   -72,  984,  604, 1386, 1045, 1012, 1045,  665, 1400,  665,
 /*   500 */  1293,  400, 1033, 1404,  651,  400, 1405,  400, 1406,  400,
 /*   510 */  1407,  400, 1408,  566, 1302,  400, 1033, 1411, 1332,  400,
 /*   520 */  1316,  400,  792, 1415, 1299,  400, 1385, 1016,  608, 1409,
 /*   530 */  1045, 1129, 1417,  476, 1418,  400, 1175,  697,  111, 1420,
 /*   540 */  1421, 1424, 1427,  400, 1416, 1429, 1410,  402, 1419,  400,
 /*   550 */  1025, 1432,  729, 1433, 1435,  -72, 1410,  400, 1441,  839,
 /*   560 */   981, 1442,  841,  981, 1443, 1439,  400, 1021, 1321,  400,
 /*   570 */  1446, 1323, 1329,  400, 1456,  -72,  -72,  -72,

};
#define YY_REDUCE_USE_DFLT (-151)
static const short yy_reduce_ofst[] = {
 /*     0 */    64,   95, -151, -151,  -59, -151, -151, -151,   33,  155,
 /*    10 */  -151,  224, -151, -151, -151, -151, -151, -151, -151,  428,
 /*    20 */  -151,  509, -151,  758, -151,  430, -151,   45,  771, -151,
 /*    30 */  -151,  -21, -151,  -64,  865,  244, -151,  910,  -85, -151,
 /*    40 */   895, -151, -151, -125, -151, -151, -151, -151, -151, -151,
 /*    50 */  -151, -151, 1010, -151, 1000, -151, -151, -151, -151, -151,
 /*    60 */  1011, 1022, 1024, -151, -151, -151, -151, 1028, -151, -151,
 /*    70 */   125, -151,  156, -151, -151, -151,  159, -151, 1037, 1039,
 /*    80 */  -151, 1040,  420, 1014, 1047, 1042, 1049, 1051, 1055, -151,
 /*    90 */   348,  411,  450,  411,  649, -151, -151, 1105, -151, 1119,
 /*   100 */  -151, -151, -151, -151, -151, -151, -151,  685,  411,  254,
 /*   110 */  -151, -151, 1108, -150, -151, -151,  -34, -151, -151, -151,
 /*   120 */  -151, 1044, -151, -151, -151, 1053, -151, -151, -151, -151,
 /*   130 */  -151, -151,  696, -151,  411,  732,  411,  743,  411,  747,
 /*   140 */   411,  749,  411,  778,  411,  786,  411,  788,  411,  797,
 /*   150 */   411,  827,  411,  838,  411,  874,  411,  882,  411,  885,
 /*   160 */   411,  887,  411,  893,  411,  901,  411, -151, -151, -151,
 /*   170 */  -151, -151, -151,  932,   39,  951,  411, -151, -151, -151,
 /*   180 */  -151, -151, -151, -151,  991,  411, 1008,  411, -151, 1126,
 /*   190 */   912, 1037, -151, -151, -151, -151, -151,  411, 1015,  411,
 /*   200 */  1018,  411, 1020,  411, 1038,  411, -151,  745, 1037, -151,
 /*   210 */   343,  411, 1058, 1059, -151, -151, 1043,  411, 1046,  411,
 /*   220 */  -151, 1099, -151, -151, -151, 1139, -151, -151, 1048,  411,
 /*   230 */  1050,  411, 1052,  411, -151, -151,  257, -151, -151, 1140,
 /*   240 */  1142, -151, -151, -151,  411, 1054,  411, -151,  276, -151,
 /*   250 */   346, 1086, 1123, -151, 1141, -151, -151,  411, 1090, 1130,
 /*   260 */  -151, 1062,  411, -151,  281, -151, 1080,  411, -151,  652,
 /*   270 */  1101, -151, -151, -151, 1156, -151, 1157, -151, -151, -151,
 /*   280 */  1159, 1158,  506, 1160, -151, -151, 1109, 1110, -151, -151,
 /*   290 */    78, -151, -151, 1167, -151, -151, 1085,  411,  -63, 1037,
 /*   300 */  1101, -151,  789, 1116, 1113, -151, 1087,   87, -151, -151,
 /*   310 */  -151, 1105, -151, -151, -151, -151,  411, -151, -151, -151,
 /*   320 */  -151, -151,  411, 1150, -151, 1174, 1151, 1149, 1152, -151,
 /*   330 */  1178, -151, -151, 1153, -151, -151, -151, -151, -151, -151,
 /*   340 */  1154, -151, 1155, -151,  433, -151, -151,  715, 1117, 1163,
 /*   350 */  -151, -151, 1120, 1166, -151, -151, 1168, -151, 1161, -151,
 /*   360 */  -151,  593, -151, 1089,  411, -151, 1170, -151, -151, 1172,
 /*   370 */  -151, -151, -151, -151, 1169, 1171, -151, 1188, -151, -151,
 /*   380 */  -151,  526, 1182, -151, 1177, -151, -151,  574, -151, 1183,
 /*   390 */  -151, 1091,  142, -151, -151, -151,  621, -151, -151, 1199,
 /*   400 */  1179, 1184,  193, -151, -151, -151, -151, -151, -151,  804,
 /*   410 */  1037,  755, -151, 1203, 1204, -151, 1209, 1206, -151,  830,
 /*   420 */  1037, 1213, 1211, 1134, 1131, -151,  261, 1215, -151, 1136,
 /*   430 */  1137, -151,  774,  411, -151, -151, -151, -151, -151, -151,
 /*   440 */  -151,  516, -151, -151, -151, -151, -151, -151, -151, 1228,
 /*   450 */  1225, -151, 1231, -151,  668, -151, 1212, -151, -151, -151,
 /*   460 */   218, 1037, 1201,  840, -151, -151, -151, -151, -151, -151,
 /*   470 */   280, -151, 1214, 1249, -151,  295, 1200, 1251, -151,  821,
 /*   480 */   411, -151, -151, 1093,  411, -151, 1254, 1189,  905, -151,
 /*   490 */  -151,  904, 1037, -151,  413, -151, 1095,  411, -151,  411,
 /*   500 */  -151, 1260, 1216, -151, -151,  926, -151,  966, -151,  967,
 /*   510 */  -151,  978, -151, 1037, -151,  980, 1222, -151, 1234,  982,
 /*   520 */  -151,  924, 1227, -151, -151,  993, 1217,  922, 1037, -151,
 /*   530 */   591, -151, -151, 1277, -151, 1281, 1280, -151,  145, -151,
 /*   540 */  -151, -151, -151, 1286, -151, -151, 1202, 1283, -151, 1297,
 /*   550 */  1218, -151, 1285, -151, -151, -151, 1207, 1303, -151, 1305,
 /*   560 */  1298, -151, 1307, 1306, -151, -151,  -73, -151, -151, 1311,
 /*   570 */  -151, -151, 1223,  607, -151, -151, -151, -151,

};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */   584,  584,  579,  582,  888,  888,  888,  583,  590,  888,
 /*    10 */   888,  888,  888,  610,  611,  612,  591,  592,  593,  888,
 /*    20 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
 /*    30 */   888,  888,  603,  613,  623,  605,  622,  888,  888,  624,
 /*    40 */   668,  631,  888,  888,  669,  672,  673,  674,  868,  869,
 /*    50 */   870,  888,  668,  632,  653,  651,  888,  654,  655,  888,
 /*    60 */   724,  668,  639,  633,  640,  722,  723,  668,  634,  888,
 /*    70 */   888,  754,  820,  760,  755,  751,  888,  679,  888,  888,
 /*    80 */   680,  688,  690,  697,  736,  727,  729,  717,  731,  685,
 /*    90 */   888,  732,  888,  733,  888,  753,  888,  888,  756,  888,
 /*   100 */   757,  758,  759,  761,  762,  763,  888,  888,  888,  888,
 /*   110 */   608,  609,  615,  843,  888,  616,  843,  888,  617,  620,
 /*   120 */   621,  888,  838,  840,  841,  888,  839,  842,  619,  618,
 /*   130 */   888,  764,  888,  767,  769,  888,  770,  888,  771,  888,
 /*   140 */   772,  888,  773,  888,  774,  888,  775,  888,  776,  888,
 /*   150 */   777,  888,  778,  888,  779,  888,  780,  888,  781,  888,
 /*   160 */   782,  888,  783,  888,  784,  888,  785,  786,  888,  787,
 /*   170 */   794,  801,  804,  888,  789,  888,  788,  791,  888,  792,
 /*   180 */   888,  795,  793,  800,  888,  888,  888,  802,  803,  888,
 /*   190 */   820,  888,  888,  888,  888,  888,  807,  819,  888,  796,
 /*   200 */   888,  797,  888,  798,  888,  799,  888,  888,  888,  809,
 /*   210 */   888,  888,  888,  888,  888,  810,  888,  888,  888,  811,
 /*   220 */   888,  888,  888,  866,  888,  888,  888,  867,  888,  888,
 /*   230 */   888,  888,  888,  812,  888,  805,  820,  817,  818,  705,
 /*   240 */   888,  706,  808,  790,  768,  888,  734,  888,  888,  718,
 /*   250 */   888,  725,  724,  719,  888,  607,  726,  721,  725,  724,
 /*   260 */   720,  888,  730,  888,  820,  728,  888,  737,  689,  700,
 /*   270 */   698,  699,  708,  709,  888,  710,  888,  711,  888,  712,
 /*   280 */   888,  705,  696,  888,  694,  695,  714,  716,  701,  888,
 /*   290 */   888,  888,  715,  888,  749,  750,  888,  713,  700,  888,
 /*   300 */   888,  888,  696,  714,  716,  702,  888,  696,  691,  692,
 /*   310 */   888,  888,  693,  686,  687,  806,  888,  752,  888,  765,
 /*   320 */   888,  766,  888,  668,  635,  888,  824,  641,  636,  642,
 /*   330 */   888,  643,  888,  888,  644,  888,  647,  648,  649,  650,
 /*   340 */   888,  645,  888,  646,  888,  888,  825,  888,  725,  724,
 /*   350 */   826,  828,  725,  724,  827,  637,  888,  638,  653,  652,
 /*   360 */   625,  888,  626,  888,  888,  627,  888,  628,  760,  888,
 /*   370 */   629,  630,  614,  606,  888,  888,  658,  888,  661,  888,
 /*   380 */   888,  888,  888,  888,  668,  662,  888,  888,  888,  668,
 /*   390 */   663,  888,  668,  664,  888,  888,  888,  888,  888,  888,
 /*   400 */   824,  641,  666,  888,  665,  667,  659,  660,  604,  888,
 /*   410 */   888,  600,  888,  888,  705,  598,  888,  888,  888,  888,
 /*   420 */   888,  888,  705,  849,  888,  888,  888,  705,  707,  854,
 /*   430 */   888,  888,  888,  888,  888,  888,  855,  856,  888,  888,
 /*   440 */   888,  888,  888,  846,  847,  888,  848,  599,  888,  888,
 /*   450 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
 /*   460 */   888,  888,  888,  888,  671,  888,  888,  888,  888,  888,
 /*   470 */   888,  888,  670,  888,  888,  888,  888,  888,  888,  888,
 /*   480 */   739,  888,  888,  888,  740,  888,  888,  747,  888,  888,
 /*   490 */   748,  888,  888,  888,  888,  888,  888,  745,  888,  746,
 /*   500 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
 /*   510 */   888,  888,  888,  888,  888,  888,  888,  888,  670,  888,
 /*   520 */   888,  888,  888,  888,  888,  888,  747,  888,  888,  888,
 /*   530 */   888,  888,  888,  888,  888,  888,  705,  888,  843,  888,
 /*   540 */   888,  888,  888,  888,  888,  888,  877,  888,  888,  888,
 /*   550 */   888,  888,  888,  888,  888,  876,  877,  888,  888,  888,
 /*   560 */   888,  888,  888,  888,  888,  888,  888,  888,  888,  888,
 /*   570 */   888,  888,  886,  888,  888,  887,  585,  580,

};
#define YY_SZ_ACTTAB (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.