text: /*
  ** 2001 September 15
  **
  ** The author disclaims copyright to this source code.  In place of
  ** a legal notice, here is a blessing:
  **
  **    May you do good and not evil.
  **    May you find forgiveness for yourself and forgive others.
  **    May you share freely, never taking more than you give.
  **
  *************************************************************************
  ** Utility functions used throughout sqlite.
  **
  ** This file contains functions for allocating memory, comparing
  ** strings, and stuff like that.
  **
  */
  #include "sqliteInt.h"
  #include <stdarg.h>
  #if HAVE_ISNAN || SQLITE_HAVE_ISNAN
  # include <math.h>
  #endif
  
  /*
  ** Routine needed to support the testcase() macro.
  */
  #ifdef SQLITE_COVERAGE_TEST
  void sqlite3Coverage(int x){
    static unsigned dummy = 0;
    dummy += (unsigned)x;
  }
  #endif
  
  /*
  ** Calls to sqlite3FaultSim() are used to simulate a failure during testing,
  ** or to bypass normal error detection during testing in order to let 
  ** execute proceed futher downstream.
  **
  ** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0).  The
  ** sqlite3FaultSim() function only returns non-zero during testing.
  **
  ** During testing, if the test harness has set a fault-sim callback using
  ** a call to sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL), then
  ** each call to sqlite3FaultSim() is relayed to that application-supplied
  ** callback and the integer return value form the application-supplied
  ** callback is returned by sqlite3FaultSim().
  **
  ** The integer argument to sqlite3FaultSim() is a code to identify which
  ** sqlite3FaultSim() instance is being invoked. Each call to sqlite3FaultSim()
  ** should have a unique code.  To prevent legacy testing applications from
  ** breaking, the codes should not be changed or reused.
  */
  #ifndef SQLITE_UNTESTABLE
  int sqlite3FaultSim(int iTest){
    int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback;
    return xCallback ? xCallback(iTest) : SQLITE_OK;
  }
  #endif
  
  #ifndef SQLITE_OMIT_FLOATING_POINT
  /*
  ** Return true if the floating point value is Not a Number (NaN).
  **
  ** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.
  ** Otherwise, we have our own implementation that works on most systems.
  */
  int sqlite3IsNaN(double x){
    int rc;   /* The value return */
  #if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN
    /*
    ** Systems that support the isnan() library function should probably
    ** make use of it by compiling with -DSQLITE_HAVE_ISNAN.  But we have
    ** found that many systems do not have a working isnan() function so
    ** this implementation is provided as an alternative.
    **
    ** This NaN test sometimes fails if compiled on GCC with -ffast-math.
    ** On the other hand, the use of -ffast-math comes with the following
    ** warning:
    **
    **      This option [-ffast-math] should never be turned on by any
    **      -O option since it can result in incorrect output for programs
    **      which depend on an exact implementation of IEEE or ISO 
    **      rules/specifications for math functions.
    **
    ** Under MSVC, this NaN test may fail if compiled with a floating-
    ** point precision mode other than /fp:precise.  From the MSDN 
    ** documentation:
    **
    **      The compiler [with /fp:precise] will properly handle comparisons 
    **      involving NaN. For example, x != x evaluates to true if x is NaN 
    **      ...
    */
  #ifdef __FAST_MATH__
  # error SQLite will not work correctly with the -ffast-math option of GCC.
  #endif
    volatile double y = x;
    volatile double z = y;
    rc = (y!=z);
  #else  /* if HAVE_ISNAN */
    rc = isnan(x);
  #endif /* HAVE_ISNAN */
    testcase( rc );
    return rc;
  }
  #endif /* SQLITE_OMIT_FLOATING_POINT */
  
  /*
  ** Compute a string length that is limited to what can be stored in
  ** lower 30 bits of a 32-bit signed integer.
  **
  ** The value returned will never be negative.  Nor will it ever be greater
  ** than the actual length of the string.  For very long strings (greater
  ** than 1GiB) the value returned might be less than the true string length.
  */
  int sqlite3Strlen30(const char *z){
    if( z==0 ) return 0;
    return 0x3fffffff & (int)strlen(z);
  }
  
  /*
  ** Return the declared type of a column.  Or return zDflt if the column 
  ** has no declared type.
  **
  ** The column type is an extra string stored after the zero-terminator on
  ** the column name if and only if the COLFLAG_HASTYPE flag is set.
  */
  char *sqlite3ColumnType(Column *pCol, char *zDflt){
    if( (pCol->colFlags & COLFLAG_HASTYPE)==0 ) return zDflt;
    return pCol->zName + strlen(pCol->zName) + 1;
  }
  
  /*
  ** Helper function for sqlite3Error() - called rarely.  Broken out into
  ** a separate routine to avoid unnecessary register saves on entry to
  ** sqlite3Error().
  */
  static SQLITE_NOINLINE void  sqlite3ErrorFinish(sqlite3 *db, int err_code){
    if( db->pErr ) sqlite3ValueSetNull(db->pErr);
    sqlite3SystemError(db, err_code);
  }
  
  /*
  ** Set the current error code to err_code and clear any prior error message.
  ** Also set iSysErrno (by calling sqlite3System) if the err_code indicates
  ** that would be appropriate.
  */
  void sqlite3Error(sqlite3 *db, int err_code){
    assert( db!=0 );
    db->errCode = err_code;
    if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code);
  }
  
  /*
  ** Load the sqlite3.iSysErrno field if that is an appropriate thing
  ** to do based on the SQLite error code in rc.
  */
  void sqlite3SystemError(sqlite3 *db, int rc){
    if( rc==SQLITE_IOERR_NOMEM ) return;
    rc &= 0xff;
    if( rc==SQLITE_CANTOPEN || rc==SQLITE_IOERR ){
      db->iSysErrno = sqlite3OsGetLastError(db->pVfs);
    }
  }
  
  /*
  ** Set the most recent error code and error string for the sqlite
  ** handle "db". The error code is set to "err_code".
  **
  ** If it is not NULL, string zFormat specifies the format of the
  ** error string in the style of the printf functions: The following
  ** format characters are allowed:
  **
  **      %s      Insert a string
  **      %z      A string that should be freed after use
  **      %d      Insert an integer
  **      %T      Insert a token
  **      %S      Insert the first element of a SrcList
  **
  ** zFormat and any string tokens that follow it are assumed to be
  ** encoded in UTF-8.
  **
  ** To clear the most recent error for sqlite handle "db", sqlite3Error
  ** should be called with err_code set to SQLITE_OK and zFormat set
  ** to NULL.
  */
  void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){
    assert( db!=0 );
    db->errCode = err_code;
    sqlite3SystemError(db, err_code);
    if( zFormat==0 ){
      sqlite3Error(db, err_code);
    }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){
      char *z;
      va_list ap;
      va_start(ap, zFormat);
      z = sqlite3VMPrintf(db, zFormat, ap);
      va_end(ap);
      sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
    }
  }
  
  /*
  ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
  ** The following formatting characters are allowed:
  **
  **      %s      Insert a string
  **      %z      A string that should be freed after use
  **      %d      Insert an integer
  **      %T      Insert a token
  **      %S      Insert the first element of a SrcList
  **
  ** This function should be used to report any error that occurs while
  ** compiling an SQL statement (i.e. within sqlite3_prepare()). The
  ** last thing the sqlite3_prepare() function does is copy the error
  ** stored by this function into the database handle using sqlite3Error().
  ** Functions sqlite3Error() or sqlite3ErrorWithMsg() should be used
  ** during statement execution (sqlite3_step() etc.).
  */
  void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
    char *zMsg;
    va_list ap;
    sqlite3 *db = pParse->db;
    va_start(ap, zFormat);
    zMsg = sqlite3VMPrintf(db, zFormat, ap);
    va_end(ap);
    if( db->suppressErr ){
      sqlite3DbFree(db, zMsg);
    }else{
      pParse->nErr++;
      sqlite3DbFree(db, pParse->zErrMsg);
      pParse->zErrMsg = zMsg;
      pParse->rc = SQLITE_ERROR;
    }
  }
  
  /*
  ** If database connection db is currently parsing SQL, then transfer
  ** error code errCode to that parser if the parser has not already
  ** encountered some other kind of error.
  */
  int sqlite3ErrorToParser(sqlite3 *db, int errCode){
    Parse *pParse;
    if( db==0 || (pParse = db->pParse)==0 ) return errCode;
    pParse->rc = errCode;
    pParse->nErr++;
    return errCode;
  }
  
  /*
  ** Convert an SQL-style quoted string into a normal string by removing
  ** the quote characters.  The conversion is done in-place.  If the
  ** input does not begin with a quote character, then this routine
  ** is a no-op.
  **
  ** The input string must be zero-terminated.  A new zero-terminator
  ** is added to the dequoted string.
  **
  ** The return value is -1 if no dequoting occurs or the length of the
  ** dequoted string, exclusive of the zero terminator, if dequoting does
  ** occur.
  **
  ** 2002-02-14: This routine is extended to remove MS-Access style
  ** brackets from around identifiers.  For example:  "[a-b-c]" becomes
  ** "a-b-c".
  */
  void sqlite3Dequote(char *z){
    char quote;
    int i, j;
    if( z==0 ) return;
    quote = z[0];
    if( !sqlite3Isquote(quote) ) return;
    if( quote=='[' ) quote = ']';
    for(i=1, j=0;; i++){
      assert( z[i] );
      if( z[i]==quote ){
        if( z[i+1]==quote ){
          z[j++] = quote;
          i++;
        }else{
          break;
        }
      }else{
        z[j++] = z[i];
      }
    }
    z[j] = 0;
  }
  void sqlite3DequoteExpr(Expr *p){
    assert( sqlite3Isquote(p->u.zToken[0]) );
    p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted;
    sqlite3Dequote(p->u.zToken);
  }
  
  #if defined(SQLITE_BUILDING_FOR_COMDB2)
  /* return true if string is correctly quoted
   * ie first and last char are a quote...
   * note that string should be null terminated
   */
  int sqlite3IsCorrectlyQuoted(char *z){
    char quote = z[0];
    int i = 1;
    if( !sqlite3Isquote(quote) ) return 1;
    while( z[i]!='\0' ) i++;
    if( i>1 ) return z[i-1]==quote;
    return 0;
  }
  int sqlite3IsCorrectlyBraced(char *z){
    int i = 1;
    int q = 0;
    if( z[0]=='\0' ) return 0; /* empty string? */
    while( z[i]!='\0' ){
      if( z[i]=='{' || (z[i]=='}' && z[i+1]!='\0') ){ q++; }
      i++;
    }
    if( q>0 ) return 0; /* braces inside content? */
    if( i>1 ){
      if( z[0]=='{' && z[i-1]=='}' ){
        return 1;
      }else if( z[0]!='{' && z[0]!='}' && z[i-1]!='{' && z[i-1]!='}' ){
        return 1;
      }
    }
    return 0;
  }
  #endif /* defined(SQLITE_BUILDING_FOR_COMDB2) */
  
  /*
  ** Generate a Token object from a string
  */
  void sqlite3TokenInit(Token *p, char *z){
    p->z = z;
    p->n = sqlite3Strlen30(z);
  }
  
  /* Convenient short-hand */
  #define UpperToLower sqlite3UpperToLower
  
  /*
  ** Some systems have stricmp().  Others have strcasecmp().  Because
  ** there is no consistency, we will define our own.
  **
  ** IMPLEMENTATION-OF: R-30243-02494 The sqlite3_stricmp() and
  ** sqlite3_strnicmp() APIs allow applications and extensions to compare
  ** the contents of two buffers containing UTF-8 strings in a
  ** case-independent fashion, using the same definition of "case
  ** independence" that SQLite uses internally when comparing identifiers.
  */
  int sqlite3_stricmp(const char *zLeft, const char *zRight){
    if( zLeft==0 ){
      return zRight ? -1 : 0;
    }else if( zRight==0 ){
      return 1;
    }
    return sqlite3StrICmp(zLeft, zRight);
  }
  int sqlite3StrICmp(const char *zLeft, const char *zRight){
    unsigned char *a, *b;
    int c;
    a = (unsigned char *)zLeft;
    b = (unsigned char *)zRight;
    for(;;){
      c = (int)UpperToLower[*a] - (int)UpperToLower[*b];
      if( c || *a==0 ) break;
      a++;
      b++;
    }
    return c;
  }
  int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
    register unsigned char *a, *b;
    if( zLeft==0 ){
      return zRight ? -1 : 0;
    }else if( zRight==0 ){
      return 1;
    }
    a = (unsigned char *)zLeft;
    b = (unsigned char *)zRight;
    while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
    return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
  }
  
  /*
  ** Compute 10 to the E-th power.  Examples:  E==1 results in 10.
  ** E==2 results in 100.  E==50 results in 1.0e50.
  **
  ** This routine only works for values of E between 1 and 341.
  */
  static LONGDOUBLE_TYPE sqlite3Pow10(int E){
  #if defined(_MSC_VER)
    static const LONGDOUBLE_TYPE x[] = {
      1.0e+001,
      1.0e+002,
      1.0e+004,
      1.0e+008,
      1.0e+016,
      1.0e+032,
      1.0e+064,
      1.0e+128,
      1.0e+256
    };
    LONGDOUBLE_TYPE r = 1.0;
    int i;
    assert( E>=0 && E<=307 );
    for(i=0; E!=0; i++, E >>=1){
      if( E & 1 ) r *= x[i];
    }
    return r;
  #else
    LONGDOUBLE_TYPE x = 10.0;
    LONGDOUBLE_TYPE r = 1.0;
    while(1){
      if( E & 1 ) r *= x;
      E >>= 1;
      if( E==0 ) break;
      x *= x;
    }
    return r; 
  #endif
  }
  
  /*
  ** The string z[] is an text representation of a real number.
  ** Convert this string to a double and write it into *pResult.
  **
  ** The string z[] is length bytes in length (bytes, not characters) and
  ** uses the encoding enc.  The string is not necessarily zero-terminated.
  **
  ** Return TRUE if the result is a valid real number (or integer) and FALSE
  ** if the string is empty or contains extraneous text.  Valid numbers
  ** are in one of these formats:
  **
  **    [+-]digits[E[+-]digits]
  **    [+-]digits.[digits][E[+-]digits]
  **    [+-].digits[E[+-]digits]
  **
  ** Leading and trailing whitespace is ignored for the purpose of determining
  ** validity.
  **
  ** If some prefix of the input string is a valid number, this routine
  ** returns FALSE but it still converts the prefix and writes the result
  ** into *pResult.
  */
  int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
  #ifndef SQLITE_OMIT_FLOATING_POINT
    int incr;
    const char *zEnd = z + length;
    /* sign * significand * (10 ^ (esign * exponent)) */
    int sign = 1;    /* sign of significand */
    i64 s = 0;       /* significand */
    int d = 0;       /* adjust exponent for shifting decimal point */
    int esign = 1;   /* sign of exponent */
    int e = 0;       /* exponent */
    int eValid = 1;  /* True exponent is either not used or is well-formed */
    double result;
    int nDigits = 0;
    int nonNum = 0;  /* True if input contains UTF16 with high byte non-zero */
  
    assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
    *pResult = 0.0;   /* Default return value, in case of an error */
  
    if( enc==SQLITE_UTF8 ){
      incr = 1;
    }else{
      int i;
      incr = 2;
      assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
      for(i=3-enc; i<length && z[i]==0; i+=2){}
      nonNum = i<length;
      zEnd = &z[i^1];
      z += (enc&1);
    }
  
    /* skip leading spaces */
    while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
    if( z>=zEnd ) return 0;
  
    /* get sign of significand */
    if( *z=='-' ){
      sign = -1;
      z+=incr;
    }else if( *z=='+' ){
      z+=incr;
    }
  
    /* copy max significant digits to significand */
    while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
      s = s*10 + (*z - '0');
      z+=incr; nDigits++;
    }
  
    /* skip non-significant significand digits
    ** (increase exponent by d to shift decimal left) */
    while( z<zEnd && sqlite3Isdigit(*z) ){ z+=incr; nDigits++; d++; }
    if( z>=zEnd ) goto do_atof_calc;
  
    /* if decimal point is present */
    if( *z=='.' ){
      z+=incr;
      /* copy digits from after decimal to significand
      ** (decrease exponent by d to shift decimal right) */
      while( z<zEnd && sqlite3Isdigit(*z) ){
        if( s<((LARGEST_INT64-9)/10) ){
          s = s*10 + (*z - '0');
          d--;
        }
        z+=incr; nDigits++;
      }
    }
    if( z>=zEnd ) goto do_atof_calc;
  
    /* if exponent is present */
    if( *z=='e' || *z=='E' ){
      z+=incr;
      eValid = 0;
  
      /* This branch is needed to avoid a (harmless) buffer overread.  The 
      ** special comment alerts the mutation tester that the correct answer
      ** is obtained even if the branch is omitted */
      if( z>=zEnd ) goto do_atof_calc;              /*PREVENTS-HARMLESS-OVERREAD*/
  
      /* get sign of exponent */
      if( *z=='-' ){
        esign = -1;
        z+=incr;
      }else if( *z=='+' ){
        z+=incr;
      }
      /* copy digits to exponent */
      while( z<zEnd && sqlite3Isdigit(*z) ){
        e = e<10000 ? (e*10 + (*z - '0')) : 10000;
        z+=incr;
        eValid = 1;
      }
    }
  
    /* skip trailing spaces */
    while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
  
  do_atof_calc:
    /* adjust exponent by d, and update sign */
    e = (e*esign) + d;
    if( e<0 ) {
      esign = -1;
      e *= -1;
    } else {
      esign = 1;
    }
  
    if( s==0 ) {
      /* In the IEEE 754 standard, zero is signed. */
      result = sign<0 ? -(double)0 : (double)0;
    } else {
      /* Attempt to reduce exponent.
      **
      ** Branches that are not required for the correct answer but which only
      ** help to obtain the correct answer faster are marked with special
      ** comments, as a hint to the mutation tester.
      */
      while( e>0 ){                                       /*OPTIMIZATION-IF-TRUE*/
        if( esign>0 ){
          if( s>=(LARGEST_INT64/10) ) break;             /*OPTIMIZATION-IF-FALSE*/
          s *= 10;
        }else{
          if( s%10!=0 ) break;                           /*OPTIMIZATION-IF-FALSE*/
          s /= 10;
        }
        e--;
      }
  
      /* adjust the sign of significand */
      s = sign<0 ? -s : s;
  
      if( e==0 ){                                         /*OPTIMIZATION-IF-TRUE*/
        result = (double)s;
      }else{
        /* attempt to handle extremely small/large numbers better */
        if( e>307 ){                                      /*OPTIMIZATION-IF-TRUE*/
          if( e<342 ){                                    /*OPTIMIZATION-IF-TRUE*/
            LONGDOUBLE_TYPE scale = sqlite3Pow10(e-308);
            if( esign<0 ){
              result = s / scale;
              result /= 1.0e+308;
            }else{
              result = s * scale;
              result *= 1.0e+308;
            }
          }else{ assert( e>=342 );
            if( esign<0 ){
              result = 0.0*s;
            }else{
  #ifdef INFINITY
              result = INFINITY*s;
  #else
              result = 1e308*1e308*s;  /* Infinity */
  #endif
            }
          }
        }else{
          LONGDOUBLE_TYPE scale = sqlite3Pow10(e);
          if( esign<0 ){
            result = s / scale;
          }else{
            result = s * scale;
          }
        }
      }
    }
  
    /* store the result */
    *pResult = result;
  
    /* return true if number and no extra non-whitespace chracters after */
    return z==zEnd && nDigits>0 && eValid && nonNum==0;
  #else
    return !sqlite3Atoi64(z, pResult, length, enc);
  #endif /* SQLITE_OMIT_FLOATING_POINT */
  }
  
  /*
  ** Compare the 19-character string zNum against the text representation
  ** value 2^63:  9223372036854775808.  Return negative, zero, or positive
  ** if zNum is less than, equal to, or greater than the string.
  ** Note that zNum must contain exactly 19 characters.
  **
  ** Unlike memcmp() this routine is guaranteed to return the difference
  ** in the values of the last digit if the only difference is in the
  ** last digit.  So, for example,
  **
  **      compare2pow63("9223372036854775800", 1)
  **
  ** will return -8.
  */
  static int compare2pow63(const char *zNum, int incr){
    int c = 0;
    int i;
                      /* 012345678901234567 */
    const char *pow63 = "922337203685477580";
    for(i=0; c==0 && i<18; i++){
      c = (zNum[i*incr]-pow63[i])*10;
    }
    if( c==0 ){
      c = zNum[18*incr] - '8';
      testcase( c==(-1) );
      testcase( c==0 );
      testcase( c==(+1) );
    }
    return c;
  }
  
  /*
  ** Convert zNum to a 64-bit signed integer.  zNum must be decimal. This
  ** routine does *not* accept hexadecimal notation.
  **
  ** Returns:
  **
  **     0    Successful transformation.  Fits in a 64-bit signed integer.
  **     1    Excess non-space text after the integer value
  **     2    Integer too large for a 64-bit signed integer or is malformed
  **     3    Special case of 9223372036854775808
  **
  ** length is the number of bytes in the string (bytes, not characters).
  ** The string is not necessarily zero-terminated.  The encoding is
  ** given by enc.
  */
  int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
    int incr;
    u64 u = 0;
    int neg = 0; /* assume positive */
    int i;
    int c = 0;
    int nonNum = 0;  /* True if input contains UTF16 with high byte non-zero */
    int rc;          /* Baseline return code */
    const char *zStart;
    const char *zEnd = zNum + length;
    assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
    if( enc==SQLITE_UTF8 ){
      incr = 1;
    }else{
      incr = 2;
      assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
      for(i=3-enc; i<length && zNum[i]==0; i+=2){}
      nonNum = i<length;
      zEnd = &zNum[i^1];
      zNum += (enc&1);
    }
    while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
    if( zNum<zEnd ){
      if( *zNum=='-' ){
        neg = 1;
        zNum+=incr;
      }else if( *zNum=='+' ){
        zNum+=incr;
      }
    }
    zStart = zNum;
    while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
    for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
      u = u*10 + c - '0';
    }
    testcase( i==18*incr );
    testcase( i==19*incr );
    testcase( i==20*incr );
    if( u>LARGEST_INT64 ){
      /* This test and assignment is needed only to suppress UB warnings
      ** from clang and -fsanitize=undefined.  This test and assignment make
      ** the code a little larger and slower, and no harm comes from omitting
      ** them, but we must appaise the undefined-behavior pharisees. */
      *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
    }else if( neg ){
      *pNum = -(i64)u;
    }else{
      *pNum = (i64)u;
    }
    rc = 0;
    if( (i==0 && zStart==zNum)     /* No digits */
     || nonNum                     /* UTF16 with high-order bytes non-zero */
    ){
      rc = 1;
    }else if( &zNum[i]<zEnd ){     /* Extra bytes at the end */
      int jj = i;
      do{
        if( !sqlite3Isspace(zNum[jj]) ){
          rc = 1;          /* Extra non-space text after the integer */
          break;
        }
        jj += incr;
      }while( &zNum[jj]<zEnd );
    }
    if( i<19*incr ){
      /* Less than 19 digits, so we know that it fits in 64 bits */
      assert( u<=LARGEST_INT64 );
      return rc;
    }else{
      /* zNum is a 19-digit numbers.  Compare it against 9223372036854775808. */
      c = i>19*incr ? 1 : compare2pow63(zNum, incr);
      if( c<0 ){
        /* zNum is less than 9223372036854775808 so it fits */
        assert( u<=LARGEST_INT64 );
        return rc;
      }else{
        *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
        if( c>0 ){
          /* zNum is greater than 9223372036854775808 so it overflows */
          return 2;
        }else{
          /* zNum is exactly 9223372036854775808.  Fits if negative.  The
          ** special case 2 overflow if positive */
          assert( u-1==LARGEST_INT64 );
          return neg ? rc : 3;
        }
      }
    }
  }
  
  /*
  ** Transform a UTF-8 integer literal, in either decimal or hexadecimal,
  ** into a 64-bit signed integer.  This routine accepts hexadecimal literals,
  ** whereas sqlite3Atoi64() does not.
  **
  ** Returns:
  **
  **     0    Successful transformation.  Fits in a 64-bit signed integer.
  **     1    Excess text after the integer value
  **     2    Integer too large for a 64-bit signed integer or is malformed
  **     3    Special case of 9223372036854775808
  */
  int sqlite3DecOrHexToI64(const char *z, i64 *pOut){
  #ifndef SQLITE_OMIT_HEX_INTEGER
    if( z[0]=='0'
     && (z[1]=='x' || z[1]=='X')
    ){
      u64 u = 0;
      int i, k;
      for(i=2; z[i]=='0'; i++){}
      for(k=i; sqlite3Isxdigit(z[k]); k++){
        u = u*16 + sqlite3HexToInt(z[k]);
      }
      memcpy(pOut, &u, 8);
      return (z[k]==0 && k-i<=16) ? 0 : 2;
    }else
  #endif /* SQLITE_OMIT_HEX_INTEGER */
    {
      return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8);
    }
  }
  
  /*
  ** If zNum represents an integer that will fit in 32-bits, then set
  ** *pValue to that integer and return true.  Otherwise return false.
  **
  ** This routine accepts both decimal and hexadecimal notation for integers.
  **
  ** Any non-numeric characters that following zNum are ignored.
  ** This is different from sqlite3Atoi64() which requires the
  ** input number to be zero-terminated.
  */
  int sqlite3GetInt32(const char *zNum, int *pValue){
    sqlite_int64 v = 0;
    int i, c;
    int neg = 0;
    if( zNum[0]=='-' ){
      neg = 1;
      zNum++;
    }else if( zNum[0]=='+' ){
      zNum++;
    }
  #ifndef SQLITE_OMIT_HEX_INTEGER
    else if( zNum[0]=='0'
          && (zNum[1]=='x' || zNum[1]=='X')
          && sqlite3Isxdigit(zNum[2])
    ){
      u32 u = 0;
      zNum += 2;
      while( zNum[0]=='0' ) zNum++;
      for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){
        u = u*16 + sqlite3HexToInt(zNum[i]);
      }
      if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){
        memcpy(pValue, &u, 4);
        return 1;
      }else{
        return 0;
      }
    }
  #endif
    if( !sqlite3Isdigit(zNum[0]) ) return 0;
    while( zNum[0]=='0' ) zNum++;
    for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
      v = v*10 + c;
    }
  
    /* The longest decimal representation of a 32 bit integer is 10 digits:
    **
    **             1234567890
    **     2^31 -> 2147483648
    */
    testcase( i==10 );
    if( i>10 ){
      return 0;
    }
    testcase( v-neg==2147483647 );
    if( v-neg>2147483647 ){
      return 0;
    }
    if( neg ){
      v = -v;
    }
    *pValue = (int)v;
    return 1;
  }
  
  /*
  ** Return a 32-bit integer value extracted from a string.  If the
  ** string is not an integer, just return 0.
  */
  int sqlite3Atoi(const char *z){
    int x = 0;
    if( z ) sqlite3GetInt32(z, &x);
    return x;
  }
  
  /*
  ** The variable-length integer encoding is as follows:
  **
  ** KEY:
  **         A = 0xxxxxxx    7 bits of data and one flag bit
  **         B = 1xxxxxxx    7 bits of data and one flag bit
  **         C = xxxxxxxx    8 bits of data
  **
  **  7 bits - A
  ** 14 bits - BA
  ** 21 bits - BBA
  ** 28 bits - BBBA
  ** 35 bits - BBBBA
  ** 42 bits - BBBBBA
  ** 49 bits - BBBBBBA
  ** 56 bits - BBBBBBBA
  ** 64 bits - BBBBBBBBC
  */
  
  /*
  ** Write a 64-bit variable-length integer to memory starting at p[0].
  ** The length of data write will be between 1 and 9 bytes.  The number
  ** of bytes written is returned.
  **
  ** A variable-length integer consists of the lower 7 bits of each byte
  ** for all bytes that have the 8th bit set and one byte with the 8th
  ** bit clear.  Except, if we get to the 9th byte, it stores the full
  ** 8 bits and is the last byte.
  */
  static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){
    int i, j, n;
    u8 buf[10];
    if( v & (((u64)0xff000000)<<32) ){
      p[8] = (u8)v;
      v >>= 8;
      for(i=7; i>=0; i--){
        p[i] = (u8)((v & 0x7f) | 0x80);
        v >>= 7;
      }
      return 9;
    }    
    n = 0;
    do{
      buf[n++] = (u8)((v & 0x7f) | 0x80);
      v >>= 7;
    }while( v!=0 );
    buf[0] &= 0x7f;
    assert( n<=9 );
    for(i=0, j=n-1; j>=0; j--, i++){
      p[i] = buf[j];
    }
    return n;
  }
  int sqlite3PutVarint(unsigned char *p, u64 v){
    if( v<=0x7f ){
      p[0] = v&0x7f;
      return 1;
    }
    if( v<=0x3fff ){
      p[0] = ((v>>7)&0x7f)|0x80;
      p[1] = v&0x7f;
      return 2;
    }
    return putVarint64(p,v);
  }
  
  /*
  ** Bitmasks used by sqlite3GetVarint().  These precomputed constants
  ** are defined here rather than simply putting the constant expressions
  ** inline in order to work around bugs in the RVT compiler.
  **
  ** SLOT_2_0     A mask for  (0x7f<<14) | 0x7f
  **
  ** SLOT_4_2_0   A mask for  (0x7f<<28) | SLOT_2_0
  */
  #define SLOT_2_0     0x001fc07f
  #define SLOT_4_2_0   0xf01fc07f
  
  
  /*
  ** Read a 64-bit variable-length integer from memory starting at p[0].
  ** Return the number of bytes read.  The value is stored in *v.
  */
  u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
    u32 a,b,s;
  
    a = *p;
    /* a: p0 (unmasked) */
    if (!(a&0x80))
    {
      *v = a;
      return 1;
    }
  
    p++;
    b = *p;
    /* b: p1 (unmasked) */
    if (!(b&0x80))
    {
      a &= 0x7f;
      a = a<<7;
      a |= b;
      *v = a;
      return 2;
    }
  
    /* Verify that constants are precomputed correctly */
    assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
    assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
  
    p++;
    a = a<<14;
    a |= *p;
    /* a: p0<<14 | p2 (unmasked) */
    if (!(a&0x80))
    {
      a &= SLOT_2_0;
      b &= 0x7f;
      b = b<<7;
      a |= b;
      *v = a;
      return 3;
    }
  
    /* CSE1 from below */
    a &= SLOT_2_0;
    p++;
    b = b<<14;
    b |= *p;
    /* b: p1<<14 | p3 (unmasked) */
    if (!(b&0x80))
    {
      b &= SLOT_2_0;
      /* moved CSE1 up */
      /* a &= (0x7f<<14)|(0x7f); */
      a = a<<7;
      a |= b;
      *v = a;
      return 4;
    }
  
    /* a: p0<<14 | p2 (masked) */
    /* b: p1<<14 | p3 (unmasked) */
    /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
    /* moved CSE1 up */
    /* a &= (0x7f<<14)|(0x7f); */
    b &= SLOT_2_0;
    s = a;
    /* s: p0<<14 | p2 (masked) */
  
    p++;
    a = a<<14;
    a |= *p;
    /* a: p0<<28 | p2<<14 | p4 (unmasked) */
    if (!(a&0x80))
    {
      /* we can skip these cause they were (effectively) done above
      ** while calculating s */
      /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
      /* b &= (0x7f<<14)|(0x7f); */
      b = b<<7;
      a |= b;
      s = s>>18;
      *v = ((u64)s)<<32 | a;
      return 5;
    }
  
    /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
    s = s<<7;
    s |= b;
    /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
  
    p++;
    b = b<<14;
    b |= *p;
    /* b: p1<<28 | p3<<14 | p5 (unmasked) */
    if (!(b&0x80))
    {
      /* we can skip this cause it was (effectively) done above in calc'ing s */
      /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
      a &= SLOT_2_0;
      a = a<<7;
      a |= b;
      s = s>>18;
      *v = ((u64)s)<<32 | a;
      return 6;
    }
  
    p++;
    a = a<<14;
    a |= *p;
    /* a: p2<<28 | p4<<14 | p6 (unmasked) */
    if (!(a&0x80))
    {
      a &= SLOT_4_2_0;
      b &= SLOT_2_0;
      b = b<<7;
      a |= b;
      s = s>>11;
      *v = ((u64)s)<<32 | a;
      return 7;
    }
  
    /* CSE2 from below */
    a &= SLOT_2_0;
    p++;
    b = b<<14;
    b |= *p;
    /* b: p3<<28 | p5<<14 | p7 (unmasked) */
    if (!(b&0x80))
    {
      b &= SLOT_4_2_0;
      /* moved CSE2 up */
      /* a &= (0x7f<<14)|(0x7f); */
      a = a<<7;
      a |= b;
      s = s>>4;
      *v = ((u64)s)<<32 | a;
      return 8;
    }
  
    p++;
    a = a<<15;
    a |= *p;
    /* a: p4<<29 | p6<<15 | p8 (unmasked) */
  
    /* moved CSE2 up */
    /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
    b &= SLOT_2_0;
    b = b<<8;
    a |= b;
  
    s = s<<4;
    b = p[-4];
    b &= 0x7f;
    b = b>>3;
    s |= b;
  
    *v = ((u64)s)<<32 | a;
  
    return 9;
  }
  
  /*
  ** Read a 32-bit variable-length integer from memory starting at p[0].
  ** Return the number of bytes read.  The value is stored in *v.
  **
  ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
  ** integer, then set *v to 0xffffffff.
  **
  ** A MACRO version, getVarint32, is provided which inlines the 
  ** single-byte case.  All code should use the MACRO version as 
  ** this function assumes the single-byte case has already been handled.
  */
  u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
    u32 a,b;
  
    /* The 1-byte case.  Overwhelmingly the most common.  Handled inline
    ** by the getVarin32() macro */
    a = *p;
    /* a: p0 (unmasked) */
  #if defined(SQLITE_BUILDING_FOR_COMDB2)
    if (!(a&0x80))
    {
      /* Values between 0 and 127 */
      *v = a;
      return 1;
    }
  #else /* defined(SQLITE_BUILDING_FOR_COMDB2) */
  #ifndef getVarint32
    if (!(a&0x80))
    {
      /* Values between 0 and 127 */
      *v = a;
      return 1;
    }
  #endif
  #endif /* defined(SQLITE_BUILDING_FOR_COMDB2) */
  
    /* The 2-byte case */
    p++;
    b = *p;
    /* b: p1 (unmasked) */
    if (!(b&0x80))
    {
      /* Values between 128 and 16383 */
      a &= 0x7f;
      a = a<<7;
      *v = a | b;
      return 2;
    }
  
    /* The 3-byte case */
    p++;
    a = a<<14;
    a |= *p;
    /* a: p0<<14 | p2 (unmasked) */
    if (!(a&0x80))
    {
      /* Values between 16384 and 2097151 */
      a &= (0x7f<<14)|(0x7f);
      b &= 0x7f;
      b = b<<7;
      *v = a | b;
      return 3;
    }
  
    /* A 32-bit varint is used to store size information in btrees.
    ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
    ** A 3-byte varint is sufficient, for example, to record the size
    ** of a 1048569-byte BLOB or string.
    **
    ** We only unroll the first 1-, 2-, and 3- byte cases.  The very
    ** rare larger cases can be handled by the slower 64-bit varint
    ** routine.
    */
  #if 1
    {
      u64 v64;
      u8 n;
  
      p -= 2;
      n = sqlite3GetVarint(p, &v64);
      assert( n>3 && n<=9 );
      if( (v64 & SQLITE_MAX_U32)!=v64 ){
        *v = 0xffffffff;
      }else{
        *v = (u32)v64;
      }
      return n;
    }
  
  #else
    /* For following code (kept for historical record only) shows an
    ** unrolling for the 3- and 4-byte varint cases.  This code is
    ** slightly faster, but it is also larger and much harder to test.
    */
    p++;
    b = b<<14;
    b |= *p;
    /* b: p1<<14 | p3 (unmasked) */
    if (!(b&0x80))
    {
      /* Values between 2097152 and 268435455 */
      b &= (0x7f<<14)|(0x7f);
      a &= (0x7f<<14)|(0x7f);
      a = a<<7;
      *v = a | b;
      return 4;
    }
  
    p++;
    a = a<<14;
    a |= *p;
    /* a: p0<<28 | p2<<14 | p4 (unmasked) */
    if (!(a&0x80))
    {
      /* Values  between 268435456 and 34359738367 */
      a &= SLOT_4_2_0;
      b &= SLOT_4_2_0;
      b = b<<7;
      *v = a | b;
      return 5;
    }
  
    /* We can only reach this point when reading a corrupt database
    ** file.  In that case we are not in any hurry.  Use the (relatively
    ** slow) general-purpose sqlite3GetVarint() routine to extract the
    ** value. */
    {
      u64 v64;
      u8 n;
  
      p -= 4;
      n = sqlite3GetVarint(p, &v64);
      assert( n>5 && n<=9 );
      *v = (u32)v64;
      return n;
    }
  #endif
  }
  
  /*
  ** Return the number of bytes that will be needed to store the given
  ** 64-bit integer.
  */
  int sqlite3VarintLen(u64 v){
    int i;
    for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); }
    return i;
  }
  
  
  /*
  ** Read or write a four-byte big-endian integer value.
  */
  u32 sqlite3Get4byte(const u8 *p){
  #if SQLITE_BYTEORDER==4321
    u32 x;
    memcpy(&x,p,4);
    return x;
  #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
    u32 x;
    memcpy(&x,p,4);
    return __builtin_bswap32(x);
  #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
    u32 x;
    memcpy(&x,p,4);
    return _byteswap_ulong(x);
  #else
    testcase( p[0]&0x80 );
    return ((unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
  #endif
  }
  void sqlite3Put4byte(unsigned char *p, u32 v){
  #if SQLITE_BYTEORDER==4321
    memcpy(p,&v,4);
  #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
    u32 x = __builtin_bswap32(v);
    memcpy(p,&x,4);
  #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
    u32 x = _byteswap_ulong(v);
    memcpy(p,&x,4);
  #else
    p[0] = (u8)(v>>24);
    p[1] = (u8)(v>>16);
    p[2] = (u8)(v>>8);
    p[3] = (u8)v;
  #endif
  }
  
  
  #if defined(SQLITE_BUILDING_FOR_COMDB2)
  /*
  ** Convert an eight-byte integer value to a double and vice versa.
  ** This method should be safe; however, it may not be the fastest.
  */
  i64 sqlite3DoubleToInt64(double rVal){
    i64 iVal;
    assert( sizeof(double)==sizeof(i64) );
    memcpy(&iVal, &rVal, sizeof(i64));
    return iVal;
  }
  double sqlite3Int64ToDouble(i64 iVal){
    double rVal;
    assert( sizeof(i64)==sizeof(double) );
    memcpy(&rVal, &iVal, sizeof(double));
    return rVal;
  }
  /*
  ** Read or write an eight-byte big-endian integer value.
  */
  u64 sqlite3Get8byte(const u8 *p){
  #if SQLITE_BYTEORDER==4321
    u64 x;
    memcpy(&x,p,8);
    return x;
  #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
    u64 x;
    memcpy(&x,p,8);
    return __builtin_bswap64(x);
  #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
    u64 x;
    memcpy(&x,p,8);
    return _byteswap_uint64(x);
  #else
    testcase( p[0]&0x80 );
    testcase( p[1]&0x80 );
    testcase( p[2]&0x80 );
    testcase( p[3]&0x80 );
    testcase( p[4]&0x80 );
    return ((u64)p[0]<<56) | ((u64)p[1]<<48) | ((u64)p[2]<<40) |
           ((u64)p[3]<<32) | ((u64)p[4]<<24) | (p[5]<<16) | (p[6]<<8) | p[7];
  #endif
  }
  void sqlite3Put8byte(unsigned char *p, u64 v){
  #if SQLITE_BYTEORDER==4321
    memcpy(p,&v,8);
  #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000
    u64 x = __builtin_bswap64(v);
    memcpy(p,&x,8);
  #elif SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300
    u64 x = _byteswap_uint64(v);
    memcpy(p,&x,8);
  #else
    p[0] = (u8)(v>>56);
    p[1] = (u8)(v>>48);
    p[2] = (u8)(v>>40);
    p[3] = (u8)(v>>32);
    p[4] = (u8)(v>>24);
    p[5] = (u8)(v>>16);
    p[6] = (u8)(v>>8);
    p[7] = (u8)v;
  #endif
  }
  #endif /* defined(SQLITE_BUILDING_FOR_COMDB2) */
  
  /*
  ** Translate a single byte of Hex into an integer.
  ** This routine only works if h really is a valid hexadecimal
  ** character:  0..9a..fA..F
  */
  u8 sqlite3HexToInt(int h){
    assert( (h>='0' && h<='9') ||  (h>='a' && h<='f') ||  (h>='A' && h<='F') );
  #ifdef SQLITE_ASCII
    h += 9*(1&(h>>6));
  #endif
  #ifdef SQLITE_EBCDIC
    h += 9*(1&~(h>>4));
  #endif
    return (u8)(h & 0xf);
  }
  
  #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
  /*
  ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
  ** value.  Return a pointer to its binary value.  Space to hold the
  ** binary value has been obtained from malloc and must be freed by
  ** the calling routine.
  */
  void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
    char *zBlob;
    int i;
  
    zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1);
    n--;
    if( zBlob ){
      for(i=0; i<n; i+=2){
        zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
      }
      zBlob[i/2] = 0;
    }
    return zBlob;
  }
  #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
  
  /*
  ** Log an error that is an API call on a connection pointer that should
  ** not have been used.  The "type" of connection pointer is given as the
  ** argument.  The zType is a word like "NULL" or "closed" or "invalid".
  */
  static void logBadConnection(const char *zType){
    sqlite3_log(SQLITE_MISUSE, 
       "API call with %s database connection pointer",
       zType
    );
  }
  
  /*
  ** Check to make sure we have a valid db pointer.  This test is not
  ** foolproof but it does provide some measure of protection against
  ** misuse of the interface such as passing in db pointers that are
  ** NULL or which have been previously closed.  If this routine returns
  ** 1 it means that the db pointer is valid and 0 if it should not be
  ** dereferenced for any reason.  The calling function should invoke
  ** SQLITE_MISUSE immediately.
  **
  ** sqlite3SafetyCheckOk() requires that the db pointer be valid for
  ** use.  sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
  ** open properly and is not fit for general use but which can be
  ** used as an argument to sqlite3_errmsg() or sqlite3_close().
  */
  int sqlite3SafetyCheckOk(sqlite3 *db){
    u32 magic;
    if( db==0 ){
      logBadConnection("NULL");
      return 0;
    }
    magic = db->magic;
    if( magic!=SQLITE_MAGIC_OPEN ){
      if( sqlite3SafetyCheckSickOrOk(db) ){
        testcase( sqlite3GlobalConfig.xLog!=0 );
        logBadConnection("unopened");
      }
      return 0;
    }else{
      return 1;
    }
  }
  int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
    u32 magic;
    magic = db->magic;
    if( magic!=SQLITE_MAGIC_SICK &&
        magic!=SQLITE_MAGIC_OPEN &&
        magic!=SQLITE_MAGIC_BUSY ){
      testcase( sqlite3GlobalConfig.xLog!=0 );
      logBadConnection("invalid");
      return 0;
    }else{
      return 1;
    }
  }
  
  /*
  ** Attempt to add, substract, or multiply the 64-bit signed value iB against
  ** the other 64-bit signed integer at *pA and store the result in *pA.
  ** Return 0 on success.  Or if the operation would have resulted in an
  ** overflow, leave *pA unchanged and return 1.
  */
  int sqlite3AddInt64(i64 *pA, i64 iB){
  #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
    return __builtin_add_overflow(*pA, iB, pA);
  #else
    i64 iA = *pA;
    testcase( iA==0 ); testcase( iA==1 );
    testcase( iB==-1 ); testcase( iB==0 );
    if( iB>=0 ){
      testcase( iA>0 && LARGEST_INT64 - iA == iB );
      testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
      if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
    }else{
      testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
      testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
      if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
    }
    *pA += iB;
    return 0; 
  #endif
  }
  int sqlite3SubInt64(i64 *pA, i64 iB){
  #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
    return __builtin_sub_overflow(*pA, iB, pA);
  #else
    testcase( iB==SMALLEST_INT64+1 );
    if( iB==SMALLEST_INT64 ){
      testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
      if( (*pA)>=0 ) return 1;
      *pA -= iB;
      return 0;
    }else{
      return sqlite3AddInt64(pA, -iB);
    }
  #endif
  }
  int sqlite3MulInt64(i64 *pA, i64 iB){
  #if GCC_VERSION>=5004000 && !defined(__INTEL_COMPILER)
    return __builtin_mul_overflow(*pA, iB, pA);
  #else
    i64 iA = *pA;
    if( iB>0 ){
      if( iA>LARGEST_INT64/iB ) return 1;
      if( iA<SMALLEST_INT64/iB ) return 1;
    }else if( iB<0 ){
      if( iA>0 ){
        if( iB<SMALLEST_INT64/iA ) return 1;
      }else if( iA<0 ){
        if( iB==SMALLEST_INT64 ) return 1;
        if( iA==SMALLEST_INT64 ) return 1;
        if( -iA>LARGEST_INT64/-iB ) return 1;
      }
    }
    *pA = iA*iB;
    return 0;
  #endif
  }
  
  /*
  ** Compute the absolute value of a 32-bit signed integer, of possible.  Or 
  ** if the integer has a value of -2147483648, return +2147483647
  */
  int sqlite3AbsInt32(int x){
    if( x>=0 ) return x;
    if( x==(int)0x80000000 ) return 0x7fffffff;
    return -x;
  }
  
  #ifdef SQLITE_ENABLE_8_3_NAMES
  /*
  ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
  ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
  ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
  ** three characters, then shorten the suffix on z[] to be the last three
  ** characters of the original suffix.
  **
  ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
  ** do the suffix shortening regardless of URI parameter.
  **
  ** Examples:
  **
  **     test.db-journal    =>   test.nal
  **     test.db-wal        =>   test.wal
  **     test.db-shm        =>   test.shm
  **     test.db-mj7f3319fa =>   test.9fa
  */
  void sqlite3FileSuffix3(const char *zBaseFilename, char *z){
  #if SQLITE_ENABLE_8_3_NAMES<2
    if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) )
  #endif
    {
      int i, sz;
      sz = sqlite3Strlen30(z);
      for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
      if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
    }
  }
  #endif
  
  /* 
  ** Find (an approximate) sum of two LogEst values.  This computation is
  ** not a simple "+" operator because LogEst is stored as a logarithmic
  ** value.
  ** 
  */
  LogEst sqlite3LogEstAdd(LogEst a, LogEst b){
    static const unsigned char x[] = {
       10, 10,                         /* 0,1 */
        9, 9,                          /* 2,3 */
        8, 8,                          /* 4,5 */
        7, 7, 7,                       /* 6,7,8 */
        6, 6, 6,                       /* 9,10,11 */
        5, 5, 5,                       /* 12-14 */
        4, 4, 4, 4,                    /* 15-18 */
        3, 3, 3, 3, 3, 3,              /* 19-24 */
        2, 2, 2, 2, 2, 2, 2,           /* 25-31 */
    };
    if( a>=b ){
      if( a>b+49 ) return a;
      if( a>b+31 ) return a+1;
      return a+x[a-b];
    }else{
      if( b>a+49 ) return b;
      if( b>a+31 ) return b+1;
      return b+x[b-a];
    }
  }
  
  /*
  ** Convert an integer into a LogEst.  In other words, compute an
  ** approximation for 10*log2(x).
  */
  LogEst sqlite3LogEst(u64 x){
    static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
    LogEst y = 40;
    if( x<8 ){
      if( x<2 ) return 0;
      while( x<8 ){  y -= 10; x <<= 1; }
    }else{
  #if GCC_VERSION>=5004000
      int i = 60 - __builtin_clzll(x);
      y += i*10;
      x >>= i;
  #else
      while( x>255 ){ y += 40; x >>= 4; }  /*OPTIMIZATION-IF-TRUE*/
      while( x>15 ){  y += 10; x >>= 1; }
  #endif
    }
    return a[x&7] + y - 10;
  }
  
  #if defined(SQLITE_BUILDING_FOR_COMDB2) || !defined(SQLITE_OMIT_VIRTUALTABLE)
  /*
  ** Convert a double into a LogEst
  ** In other words, compute an approximation for 10*log2(x).
  */
  LogEst sqlite3LogEstFromDouble(double x){
    u64 a;
    LogEst e;
    assert( sizeof(x)==8 && sizeof(a)==8 );
    if( x<=1 ) return 0;
    if( x<=2000000000 ) return sqlite3LogEst((u64)x);
    memcpy(&a, &x, 8);
    e = (a>>52) - 1022;
    return e*10;
  }
  #endif /* defined(SQLITE_BUILDING_FOR_COMDB2) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
  
  #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
      defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \
      defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
  /*
  ** Convert a LogEst into an integer.
  **
  ** Note that this routine is only used when one or more of various
  ** non-standard compile-time options is enabled.
  */
  u64 sqlite3LogEstToInt(LogEst x){
    u64 n;
    n = x%10;
    x /= 10;
    if( n>=5 ) n -= 2;
    else if( n>=1 ) n -= 1;
  #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \
      defined(SQLITE_EXPLAIN_ESTIMATED_ROWS)
    if( x>60 ) return (u64)LARGEST_INT64;
  #else
    /* If only SQLITE_ENABLE_STAT3_OR_STAT4 is on, then the largest input
    ** possible to this routine is 310, resulting in a maximum x of 31 */
    assert( x<=60 );
  #endif
    return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x);
  }
  #endif /* defined SCANSTAT or STAT4 or ESTIMATED_ROWS */
  
  /*
  ** Add a new name/number pair to a VList.  This might require that the
  ** VList object be reallocated, so return the new VList.  If an OOM
  ** error occurs, the original VList returned and the
  ** db->mallocFailed flag is set.
  **
  ** A VList is really just an array of integers.  To destroy a VList,
  ** simply pass it to sqlite3DbFree().
  **
  ** The first integer is the number of integers allocated for the whole
  ** VList.  The second integer is the number of integers actually used.
  ** Each name/number pair is encoded by subsequent groups of 3 or more
  ** integers.
  **
  ** Each name/number pair starts with two integers which are the numeric
  ** value for the pair and the size of the name/number pair, respectively.
  ** The text name overlays one or more following integers.  The text name
  ** is always zero-terminated.
  **
  ** Conceptually:
  **
  **    struct VList {
  **      int nAlloc;   // Number of allocated slots 
  **      int nUsed;    // Number of used slots 
  **      struct VListEntry {
  **        int iValue;    // Value for this entry
  **        int nSlot;     // Slots used by this entry
  **        // ... variable name goes here
  **      } a[0];
  **    }
  **
  ** During code generation, pointers to the variable names within the
  ** VList are taken.  When that happens, nAlloc is set to zero as an 
  ** indication that the VList may never again be enlarged, since the
  ** accompanying realloc() would invalidate the pointers.
  */
  VList *sqlite3VListAdd(
    sqlite3 *db,           /* The database connection used for malloc() */
    VList *pIn,            /* The input VList.  Might be NULL */
    const char *zName,     /* Name of symbol to add */
    int nName,             /* Bytes of text in zName */
    int iVal               /* Value to associate with zName */
  ){
    int nInt;              /* number of sizeof(int) objects needed for zName */
    char *z;               /* Pointer to where zName will be stored */
    int i;                 /* Index in pIn[] where zName is stored */
  
    nInt = nName/4 + 3;
    assert( pIn==0 || pIn[0]>=3 );  /* Verify ok to add new elements */
    if( pIn==0 || pIn[1]+nInt > pIn[0] ){
      /* Enlarge the allocation */
      sqlite3_int64 nAlloc = (pIn ? 2*(sqlite3_int64)pIn[0] : 10) + nInt;
      VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int));
      if( pOut==0 ) return pIn;
      if( pIn==0 ) pOut[1] = 2;
      pIn = pOut;
      pIn[0] = nAlloc;
    }
    i = pIn[1];
    pIn[i] = iVal;
    pIn[i+1] = nInt;
    z = (char*)&pIn[i+2];
    pIn[1] = i+nInt;
    assert( pIn[1]<=pIn[0] );
    memcpy(z, zName, nName);
    z[nName] = 0;
    return pIn;
  }
  
  /*
  ** Return a pointer to the name of a variable in the given VList that
  ** has the value iVal.  Or return a NULL if there is no such variable in
  ** the list
  */
  const char *sqlite3VListNumToName(VList *pIn, int iVal){
    int i, mx;
    if( pIn==0 ) return 0;
    mx = pIn[1];
    i = 2;
    do{
      if( pIn[i]==iVal ) return (char*)&pIn[i+2];
      i += pIn[i+1];
    }while( i<mx );
    return 0;
  }
  
  /*
  ** Return the number of the variable named zName, if it is in VList.
  ** or return 0 if there is no such variable.
  */
  int sqlite3VListNameToNum(VList *pIn, const char *zName, int nName){
    int i, mx;
  #if defined(SQLITE_BUILDING_FOR_COMDB2)
    int off = 0;
  #endif /* defined(SQLITE_BUILDING_FOR_COMDB2) */
    if( pIn==0 ) return 0;
    mx = pIn[1];
    i = 2;
  #if defined(SQLITE_BUILDING_FOR_COMDB2)
    if( zName[0]!='@' ) off++;
  #endif /* defined(SQLITE_BUILDING_FOR_COMDB2) */
    do{
      const char *z = (const char*)&pIn[i+2];
  #if defined(SQLITE_BUILDING_FOR_COMDB2)
      if( z && strncmp(z+off,zName,nName)==0 && z[nName+off]==0 ){
        return pIn[i];
      }
  #else /* defined(SQLITE_BUILDING_FOR_COMDB2) */
      if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
  #endif /* defined(SQLITE_BUILDING_FOR_COMDB2) */
      i += pIn[i+1];
    }while( i<mx );
    return 0;
  }
  
  #if defined(SQLITE_BUILDING_FOR_COMDB2)
  /*
  ** Create a copy of the VList 
  */
  VList *sqlite3VListClone(
    const VList *pIn,      /* The input VList.  Might be NULL */
    void *(*alloc)(size_t size)
  ){
    VList *pOut;
    if (!pIn) 
      return NULL;
  
    pOut = alloc(pIn[0]);
    if (!pOut)
      return NULL;
  
    memcpy(pOut, pIn, pIn[0]);
    return pOut;
  }
  
  #include "logmsg.h"
  void sqlite3VListPrint(loglvl lvl, const VList *pIn)
  {
    int i, mx;
  
    if (!pIn)
      return;
  
    mx = pIn[1];
    i = 2;
    logmsg(lvl, "%lx VList info start:\n", pthread_self());
    do{
      const char *z = (const char*)&pIn[i+2];
      logmsg(lvl, "%lx %s %d\n", pthread_self(), z, pIn[i]);
      i += pIn[i+1];
    }while( i<mx );
    logmsg(lvl, "%lx VList info done.\n", pthread_self());
  }
  #endif /* defined(SQLITE_BUILDING_FOR_COMDB2) */
  
  