#ifndef _SQLITEINT_H_

#define _SQLITEINT_H_

#ifndef SQLITE_DISABLE_LFS

# define _LARGE_FILE 1

# ifndef _FILE_OFFSET_BITS

# define _FILE_OFFSET_BITS 64

# define _LARGEFILE_SOURCE 1

#if defined(_HAVE_MINGW_H)

# include "mingw.h"

#elif defined(_HAVE__MINGW_H)

# include "_mingw.h"

#if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \

defined(_WIN32) && !defined(_WIN64) && \

defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \

defined(__MSVCRT__)

# define _USE_32BIT_TIME_T

#include "sqlite3.h"

#ifdef _HAVE_SQLITE_CONFIG_H

#include "config.h"

#include "sqliteLimit.h"

#if defined(__BORLANDC__)

#pragma warn -rch /* unreachable code */

#pragma warn -ccc /* Condition is always true or false */

#pragma warn -aus /* Assigned value is never used */

#pragma warn -csu /* Comparing signed and unsigned */

#pragma warn -spa /* Suspicious pointer arithmetic */

#ifndef _GNU_SOURCE

# define _GNU_SOURCE

#if defined(__OpenBSD__) && !defined(_BSD_SOURCE)

# define _BSD_SOURCE

#ifdef HAVE_STDINT_H

#include <stdint.h>

#ifdef HAVE_INTTYPES_H

#include <inttypes.h>

#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */

# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))

#elif !defined(__GNUC__) /* Works for compilers other than LLVM */

# define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])

# define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))

#elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */

# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))

#else /* Generates a warning - but it always works */

# define SQLITE_INT_TO_PTR(X) ((void*)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(X))

#if defined(__GNUC__)

# define SQLITE_NOINLINE __attribute__((noinline))

#elif defined(_MSC_VER)

# define SQLITE_NOINLINE __declspec(noinline)

# define SQLITE_NOINLINE

#if !defined(SQLITE_THREADSAFE)

# if defined(THREADSAFE)

# define SQLITE_THREADSAFE THREADSAFE

# define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */

#ifndef SQLITE_POWERSAFE_OVERWRITE

# define SQLITE_POWERSAFE_OVERWRITE 1

#if !defined(SQLITE_DEFAULT_MEMSTATUS)

# define SQLITE_DEFAULT_MEMSTATUS 1

#if defined(SQLITE_SYSTEM_MALLOC) \

+ defined(SQLITE_WIN32_MALLOC) \

+ defined(SQLITE_ZERO_MALLOC) \

+ defined(SQLITE_MEMDEBUG)>1

# error "Two or more of the following compile-time configuration options\

are defined but at most one is allowed:\

SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\

SQLITE_ZERO_MALLOC"

#if defined(SQLITE_SYSTEM_MALLOC) \

+ defined(SQLITE_WIN32_MALLOC) \

+ defined(SQLITE_ZERO_MALLOC) \

+ defined(SQLITE_MEMDEBUG)==0

# define SQLITE_SYSTEM_MALLOC 1

#if !defined(SQLITE_MALLOC_SOFT_LIMIT)

# define SQLITE_MALLOC_SOFT_LIMIT 1024

#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__)

# define _XOPEN_SOURCE 600

#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)

# define NDEBUG 1

#if defined(NDEBUG) && defined(SQLITE_DEBUG)

# undef NDEBUG

#if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG)

# define SQLITE_ENABLE_EXPLAIN_COMMENTS 1

#ifdef SQLITE_COVERAGE_TEST

void sqlite3Coverage(int);

# define testcase(X) if( X ){ sqlite3Coverage(__LINE__); }

# define testcase(X)

#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)

# define TESTONLY(X) X

# define TESTONLY(X)

#ifndef NDEBUG

# define VVA_ONLY(X) X

# define VVA_ONLY(X)

#if defined(SQLITE_COVERAGE_TEST)

# define ALWAYS(X) (1)

# define NEVER(X) (0)

#elif !defined(NDEBUG)

# define ALWAYS(X) ((X)?1:(assert(0),0))

# define NEVER(X) ((X)?(assert(0),1):0)

# define ALWAYS(X) (X)

# define NEVER(X) (X)

#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)

#define likely(X) (X)

#define unlikely(X) (X)

#include "hash.h"

#include "parse.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <stddef.h>

#ifdef SQLITE_OMIT_FLOATING_POINT

# define double sqlite_int64

# define float sqlite_int64

# define LONGDOUBLE_TYPE sqlite_int64

# ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)

# define SQLITE_OMIT_DATETIME_FUNCS 1

# define SQLITE_OMIT_TRACE 1

# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT

# undef SQLITE_HAVE_ISNAN

#ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (1e99)

#ifdef SQLITE_OMIT_TEMPDB

#define OMIT_TEMPDB 1

#define OMIT_TEMPDB 0

#define SQLITE_MAX_FILE_FORMAT 4

#ifndef SQLITE_DEFAULT_FILE_FORMAT

# define SQLITE_DEFAULT_FILE_FORMAT 4

#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS

# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0

#ifndef SQLITE_TEMP_STORE

# define SQLITE_TEMP_STORE 1

# define SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */

#if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0

# undef SQLITE_MAX_WORKER_THREADS

# define SQLITE_MAX_WORKER_THREADS 0

#ifndef SQLITE_MAX_WORKER_THREADS

# define SQLITE_MAX_WORKER_THREADS 8

#ifndef SQLITE_DEFAULT_WORKER_THREADS

# define SQLITE_DEFAULT_WORKER_THREADS 0

#if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS

# undef SQLITE_MAX_WORKER_THREADS

# define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS

#ifndef offsetof

#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))

#define MIN(A,B) ((A)<(B)?(A):(B))

#define MAX(A,B) ((A)>(B)?(A):(B))

#if 'A' == '\301'

# define SQLITE_EBCDIC 1

# define SQLITE_ASCII 1

#ifndef UINT32_TYPE

# ifdef HAVE_UINT32_T

# define UINT32_TYPE uint32_t

# define UINT32_TYPE unsigned int

#ifndef UINT16_TYPE

# ifdef HAVE_UINT16_T

# define UINT16_TYPE uint16_t

# define UINT16_TYPE unsigned short int

#ifndef INT16_TYPE

# ifdef HAVE_INT16_T

# define INT16_TYPE int16_t

# define INT16_TYPE short int

#ifndef UINT8_TYPE

# ifdef HAVE_UINT8_T

# define UINT8_TYPE uint8_t

# define UINT8_TYPE unsigned char

#ifndef INT8_TYPE

# ifdef HAVE_INT8_T

# define INT8_TYPE int8_t

# define INT8_TYPE signed char

#ifndef LONGDOUBLE_TYPE

# define LONGDOUBLE_TYPE long double

typedef sqlite_int64 i64; /* 8-byte signed integer */

typedef sqlite_uint64 u64; /* 8-byte unsigned integer */

typedef UINT32_TYPE u32; /* 4-byte unsigned integer */

typedef UINT16_TYPE u16; /* 2-byte unsigned integer */

typedef INT16_TYPE i16; /* 2-byte signed integer */

typedef UINT8_TYPE u8; /* 1-byte unsigned integer */

typedef INT8_TYPE i8; /* 1-byte signed integer */

#define SQLITE_MAX_U32 ((((u64)1)<<32)-1)

#ifdef SQLITE_64BIT_STATS

typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */

typedef u32 tRowcnt; /* 32-bit is the default */

typedef INT16_TYPE LogEst;

#ifdef SQLITE_AMALGAMATION

const int sqlite3one = 1;

extern const int sqlite3one;

#if (defined(i386) || defined(__i386__) || defined(_M_IX86) || \

defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \

defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \

defined(__arm__)) && !defined(SQLITE_RUNTIME_BYTEORDER)

# define SQLITE_BYTEORDER 1234

# define SQLITE_BIGENDIAN 0

# define SQLITE_LITTLEENDIAN 1

# define SQLITE_UTF16NATIVE SQLITE_UTF16LE

#if (defined(sparc) || defined(__ppc__)) \

&& !defined(SQLITE_RUNTIME_BYTEORDER)

# define SQLITE_BYTEORDER 4321

# define SQLITE_BIGENDIAN 1

# define SQLITE_LITTLEENDIAN 0

# define SQLITE_UTF16NATIVE SQLITE_UTF16BE

#if !defined(SQLITE_BYTEORDER)

# define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */

# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)

# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)

# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

#define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))

#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)

#define ROUND8(x) (((x)+7)&~7)

#define ROUNDDOWN8(x) ((x)&~7)

#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC

# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0)

# define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)

#if defined(__OpenBSD__) || defined(__QNXNTO__)

# undef SQLITE_MAX_MMAP_SIZE

# define SQLITE_MAX_MMAP_SIZE 0

#ifdef __APPLE__

# include <TargetConditionals.h>

# if TARGET_OS_IPHONE

# undef SQLITE_MAX_MMAP_SIZE

# define SQLITE_MAX_MMAP_SIZE 0

#ifndef SQLITE_MAX_MMAP_SIZE

# if defined(__linux__) \

|| defined(_WIN32) \

|| (defined(__APPLE__) && defined(__MACH__)) \

|| defined(__sun)

# define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */

# define SQLITE_MAX_MMAP_SIZE 0

# define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */

#ifndef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE 0

# define SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */

#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE

# undef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE

#ifdef SQLITE_ENABLE_STAT4

# undef SQLITE_ENABLE_STAT3

# define SQLITE_ENABLE_STAT3_OR_STAT4 1

#elif SQLITE_ENABLE_STAT3

# define SQLITE_ENABLE_STAT3_OR_STAT4 1

#elif SQLITE_ENABLE_STAT3_OR_STAT4

# undef SQLITE_ENABLE_STAT3_OR_STAT4

typedef struct BusyHandler BusyHandler;

struct BusyHandler {

};

#define MASTER_NAME "sqlite_master"

#define TEMP_MASTER_NAME "sqlite_temp_master"

#define MASTER_ROOT 1

#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)

#define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))

#define IsPowerOfTwo(X) (((X)&((X)-1))==0)

#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)

#ifdef SQLITE_OMIT_WSD

#define SQLITE_WSD const

#define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))

#define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)

int sqlite3_wsd_init(int N, int J);

void *sqlite3_wsd_find(void *K, int L);

#define SQLITE_WSD

#define GLOBAL(t,v) v

#define sqlite3GlobalConfig sqlite3Config

#define UNUSED_PARAMETER(x) (void)(x)

#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)

typedef struct AggInfo AggInfo;

typedef struct AuthContext AuthContext;

typedef struct AutoincInfo AutoincInfo;

typedef struct Bitvec Bitvec;

typedef struct CollSeq CollSeq;

typedef struct Column Column;

typedef struct Db Db;

typedef struct Schema Schema;

typedef struct Expr Expr;

typedef struct ExprList ExprList;

typedef struct ExprSpan ExprSpan;

typedef struct FKey FKey;

typedef struct FuncDestructor FuncDestructor;

typedef struct FuncDef FuncDef;

typedef struct FuncDefHash FuncDefHash;

typedef struct IdList IdList;

typedef struct Index Index;

typedef struct IndexSample IndexSample;

typedef struct KeyClass KeyClass;

typedef struct KeyInfo KeyInfo;

typedef struct Lookaside Lookaside;

typedef struct LookasideSlot LookasideSlot;

typedef struct Module Module;

typedef struct NameContext NameContext;

typedef struct Parse Parse;

typedef struct PrintfArguments PrintfArguments;

typedef struct RowSet RowSet;

typedef struct Savepoint Savepoint;

typedef struct Select Select;

typedef struct SQLiteThread SQLiteThread;

typedef struct SelectDest SelectDest;

typedef struct SrcList SrcList;

typedef struct StrAccum StrAccum;

typedef struct Table Table;

typedef struct TableLock TableLock;

typedef struct Token Token;

typedef struct Trigger Trigger;

typedef struct TriggerPrg TriggerPrg;

typedef struct TriggerStep TriggerStep;

typedef struct UnpackedRecord UnpackedRecord;

typedef struct VTable VTable;

typedef struct VtabCtx VtabCtx;

typedef struct Walker Walker;

typedef struct WhereInfo WhereInfo;

typedef struct With With;

#include "btree.h"

#include "vdbe.h"

#include "pager.h"

#include "pcache.h"

#include "os.h"

#include "mutex.h"

struct Db {

};

struct Schema {

};

#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P))

#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0)

#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P)

#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P)

#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */

#define DB_UnresetViews 0x0002 /* Some views have defined column names */

#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */

#define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1)

struct Lookaside {

};

struct LookasideSlot {

LookasideSlot *pNext; /* Next buffer in the list of free buffers */

};

struct FuncDefHash {

FuncDef *a[23]; /* Hash table for functions */

};

#ifdef SQLITE_USER_AUTHENTICATION

typedef struct sqlite3_userauth sqlite3_userauth;

struct sqlite3_userauth {